<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"><html xmlns="http://www.w3.org/1999/xhtml"><head><link rel="stylesheet" type="text/css" href="style.css" /><script type="text/javascript" src="highlight.js"></script></head><body><pre><span class="hs-pragma">{-# LANGUAGE Trustworthy #-}</span><span>
</span><span id="line-2"></span><span class="hs-pragma">{-# LANGUAGE CPP, NoImplicitPrelude, StandaloneDeriving, ScopedTypeVariables #-}</span><span>
</span><span id="line-3"></span><span class="hs-pragma">{-# OPTIONS_HADDOCK not-home #-}</span><span>
</span><span id="line-4"></span><span>
</span><span id="line-5"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-6"></span><span class="hs-comment">-- |</span><span>
</span><span id="line-7"></span><span class="hs-comment">-- Module      :  GHC.Read</span><span>
</span><span id="line-8"></span><span class="hs-comment">-- Copyright   :  (c) The University of Glasgow, 1994-2002</span><span>
</span><span id="line-9"></span><span class="hs-comment">-- License     :  see libraries/base/LICENSE</span><span>
</span><span id="line-10"></span><span class="hs-comment">--</span><span>
</span><span id="line-11"></span><span class="hs-comment">-- Maintainer  :  cvs-ghc@haskell.org</span><span>
</span><span id="line-12"></span><span class="hs-comment">-- Stability   :  internal</span><span>
</span><span id="line-13"></span><span class="hs-comment">-- Portability :  non-portable (GHC Extensions)</span><span>
</span><span id="line-14"></span><span class="hs-comment">--</span><span>
</span><span id="line-15"></span><span class="hs-comment">-- The 'Read' class and instances for basic data types.</span><span>
</span><span id="line-16"></span><span class="hs-comment">--</span><span>
</span><span id="line-17"></span><span class="hs-comment">-----------------------------------------------------------------------------</span><span>
</span><span id="line-18"></span><span>
</span><span id="line-19"></span><span class="hs-keyword">module</span><span> </span><span class="hs-identifier">GHC.Read</span><span>
</span><span id="line-20"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier">Read</span></a></span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span>   </span><span class="hs-comment">-- class</span><span>
</span><span id="line-21"></span><span>
</span><span id="line-22"></span><span>  </span><span class="hs-comment">-- ReadS type</span><span>
</span><span id="line-23"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier">ReadS</span></a></span><span>
</span><span id="line-24"></span><span>
</span><span id="line-25"></span><span>  </span><span class="hs-comment">-- H2010 compatibility</span><span>
</span><span id="line-26"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#lex"><span class="hs-identifier">lex</span></a></span><span>
</span><span id="line-27"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#lexLitChar"><span class="hs-identifier">lexLitChar</span></a></span><span>
</span><span id="line-28"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readLitChar"><span class="hs-identifier">readLitChar</span></a></span><span>
</span><span id="line-29"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#lexDigits"><span class="hs-identifier">lexDigits</span></a></span><span>
</span><span id="line-30"></span><span>
</span><span id="line-31"></span><span>  </span><span class="hs-comment">-- defining readers</span><span>
</span><span id="line-32"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#lexP"><span class="hs-identifier">lexP</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#expectP"><span class="hs-identifier">expectP</span></a></span><span>
</span><span id="line-33"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#paren"><span class="hs-identifier">paren</span></a></span><span>
</span><span id="line-34"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#parens"><span class="hs-identifier">parens</span></a></span><span>
</span><span id="line-35"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#list"><span class="hs-identifier">list</span></a></span><span>
</span><span id="line-36"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#choose"><span class="hs-identifier">choose</span></a></span><span>
</span><span id="line-37"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readListDefault"><span class="hs-identifier">readListDefault</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier">readListPrecDefault</span></a></span><span>
</span><span id="line-38"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readNumber"><span class="hs-identifier">readNumber</span></a></span><span>
</span><span id="line-39"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readField"><span class="hs-identifier">readField</span></a></span><span>
</span><span id="line-40"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readFieldHash"><span class="hs-identifier">readFieldHash</span></a></span><span>
</span><span id="line-41"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readSymField"><span class="hs-identifier">readSymField</span></a></span><span>
</span><span id="line-42"></span><span>
</span><span id="line-43"></span><span>  </span><span class="hs-comment">-- Temporary</span><span>
</span><span id="line-44"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#readParen"><span class="hs-identifier">readParen</span></a></span><span>
</span><span id="line-45"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-46"></span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">

#include &quot;MachDeps.h&quot;
</span><span>
</span><span id="line-50"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html"><span class="hs-identifier">Text.ParserCombinators.ReadP</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">P</span></span><span>
</span><span id="line-51"></span><span>
</span><span id="line-52"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html"><span class="hs-identifier">Text.ParserCombinators.ReadP</span></a></span><span>
</span><span id="line-53"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier">ReadS</span></a></span><span>
</span><span id="line-54"></span><span>  </span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#readP_to_S"><span class="hs-identifier">readP_to_S</span></a></span><span>
</span><span id="line-55"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-56"></span><span>
</span><span id="line-57"></span><span class="hs-keyword">import</span><span> </span><span class="hs-keyword">qualified</span><span> </span><span class="annot"><a href="Text.Read.Lex.html"><span class="hs-identifier">Text.Read.Lex</span></a></span><span> </span><span class="hs-keyword">as</span><span> </span><span class="annot"><span class="hs-identifier">L</span></span><span>
</span><span id="line-58"></span><span class="hs-comment">-- Lex exports 'lex', which is also defined here,</span><span>
</span><span id="line-59"></span><span class="hs-comment">-- hence the qualified import.</span><span>
</span><span id="line-60"></span><span class="hs-comment">-- We can't import *anything* unqualified, because that</span><span>
</span><span id="line-61"></span><span class="hs-comment">-- confuses Haddock.</span><span>
</span><span id="line-62"></span><span>
</span><span id="line-63"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html"><span class="hs-identifier">Text.ParserCombinators.ReadPrec</span></a></span><span>
</span><span id="line-64"></span><span>
</span><span id="line-65"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="Data.Maybe.html"><span class="hs-identifier">Data.Maybe</span></a></span><span>
</span><span id="line-66"></span><span>
</span><span id="line-67"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Unicode.html"><span class="hs-identifier">GHC.Unicode</span></a></span><span>
</span><span id="line-68"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Num.html"><span class="hs-identifier">GHC.Num</span></a></span><span>
</span><span id="line-69"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Real.html"><span class="hs-identifier">GHC.Real</span></a></span><span>
</span><span id="line-70"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Float.html"><span class="hs-identifier">GHC.Float</span></a></span><span>
</span><span id="line-71"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Show.html"><span class="hs-identifier">GHC.Show</span></a></span><span>
</span><span id="line-72"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Base.html"><span class="hs-identifier">GHC.Base</span></a></span><span>
</span><span id="line-73"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Arr.html"><span class="hs-identifier">GHC.Arr</span></a></span><span>
</span><span id="line-74"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.Word.html"><span class="hs-identifier">GHC.Word</span></a></span><span>
</span><span id="line-75"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="GHC.List.html"><span class="hs-identifier">GHC.List</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.List.html#filter"><span class="hs-identifier">filter</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-76"></span><span class="hs-keyword">import</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#"><span class="hs-identifier">GHC.Tuple</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier">Solo</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">..</span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-77"></span><span>
</span><span id="line-78"></span><span>
</span><span id="line-79"></span><span class="hs-comment">-- | @'readParen' 'True' p@ parses what @p@ parses, but surrounded with</span><span>
</span><span id="line-80"></span><span class="hs-comment">-- parentheses.</span><span>
</span><span id="line-81"></span><span class="hs-comment">--</span><span>
</span><span id="line-82"></span><span class="hs-comment">-- @'readParen' 'False' p@ parses what @p@ parses, but optionally</span><span>
</span><span id="line-83"></span><span class="hs-comment">-- surrounded with parentheses.</span><span>
</span><span id="line-84"></span><span id="local-6989586621679495943"><span class="annot"><a href="GHC.Read.html#readParen"><span class="hs-identifier hs-type">readParen</span></a></span><span>       </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495943"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495943"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-85"></span><span class="hs-comment">-- A Haskell 2010 function</span><span>
</span><span id="line-86"></span><span id="readParen"><span class="annot"><span class="annottext">readParen :: forall a. Bool -&gt; ReadS a -&gt; ReadS a
</span><a href="GHC.Read.html#readParen"><span class="hs-identifier hs-var hs-var">readParen</span></a></span></span><span> </span><span id="local-6989586621679495479"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679495479"><span class="hs-identifier hs-var">b</span></a></span></span><span> </span><span id="local-6989586621679495478"><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495478"><span class="hs-identifier hs-var">g</span></a></span></span><span>   </span><span class="hs-glyph">=</span><span>  </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679495479"><span class="hs-identifier hs-var">b</span></a></span><span> </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495477"><span class="hs-identifier hs-var">mandatory</span></a></span><span> </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495476"><span class="hs-identifier hs-var">optional</span></a></span><span>
</span><span id="line-87"></span><span>                   </span><span class="hs-keyword">where</span><span> </span><span id="local-6989586621679495476"><span class="annot"><span class="annottext">optional :: ReadS a
</span><a href="#local-6989586621679495476"><span class="hs-identifier hs-var hs-var">optional</span></a></span></span><span> </span><span id="local-6989586621679495467"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495467"><span class="hs-identifier hs-var">r</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495478"><span class="hs-identifier hs-var">g</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495467"><span class="hs-identifier hs-var">r</span></a></span><span> </span><span class="annot"><span class="annottext">[(a, String)] -&gt; [(a, String)] -&gt; [(a, String)]
forall a. [a] -&gt; [a] -&gt; [a]
</span><a href="GHC.Base.html#%2B%2B"><span class="hs-operator hs-var">++</span></a></span><span> </span><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495477"><span class="hs-identifier hs-var">mandatory</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495467"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-88"></span><span>                         </span><span id="local-6989586621679495477"><span class="annot"><span class="annottext">mandatory :: ReadS a
</span><a href="#local-6989586621679495477"><span class="hs-identifier hs-var hs-var">mandatory</span></a></span></span><span> </span><span id="local-6989586621679495466"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495466"><span class="hs-identifier hs-var">r</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-89"></span><span>                                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;(&quot;</span></span><span class="hs-special">,</span><span id="local-6989586621679495465"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495465"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS String
</span><a href="GHC.Read.html#lex"><span class="hs-identifier hs-var">lex</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495466"><span class="hs-identifier hs-var">r</span></a></span><span>
</span><span id="line-90"></span><span>                                </span><span class="hs-special">(</span><span id="local-6989586621679495464"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495464"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679495463"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495463"><span class="hs-identifier hs-var">t</span></a></span></span><span class="hs-special">)</span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS a
</span><a href="#local-6989586621679495476"><span class="hs-identifier hs-var">optional</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495465"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-91"></span><span>                                </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;)&quot;</span></span><span class="hs-special">,</span><span id="local-6989586621679495462"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495462"><span class="hs-identifier hs-var">u</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadS String
</span><a href="GHC.Read.html#lex"><span class="hs-identifier hs-var">lex</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495463"><span class="hs-identifier hs-var">t</span></a></span><span>
</span><span id="line-92"></span><span>                                </span><span class="annot"><span class="annottext">(a, String) -&gt; [(a, String)]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495464"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495462"><span class="hs-identifier hs-var">u</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-93"></span><span>
</span><span id="line-94"></span><span class="hs-comment">-- | Parsing of 'String's, producing values.</span><span>
</span><span id="line-95"></span><span class="hs-comment">--</span><span>
</span><span id="line-96"></span><span class="hs-comment">-- Derived instances of 'Read' make the following assumptions, which</span><span>
</span><span id="line-97"></span><span class="hs-comment">-- derived instances of 'Text.Show.Show' obey:</span><span>
</span><span id="line-98"></span><span class="hs-comment">--</span><span>
</span><span id="line-99"></span><span class="hs-comment">-- * If the constructor is defined to be an infix operator, then the</span><span>
</span><span id="line-100"></span><span class="hs-comment">--   derived 'Read' instance will parse only infix applications of</span><span>
</span><span id="line-101"></span><span class="hs-comment">--   the constructor (not the prefix form).</span><span>
</span><span id="line-102"></span><span class="hs-comment">--</span><span>
</span><span id="line-103"></span><span class="hs-comment">-- * Associativity is not used to reduce the occurrence of parentheses,</span><span>
</span><span id="line-104"></span><span class="hs-comment">--   although precedence may be.</span><span>
</span><span id="line-105"></span><span class="hs-comment">--</span><span>
</span><span id="line-106"></span><span class="hs-comment">-- * If the constructor is defined using record syntax, the derived 'Read'</span><span>
</span><span id="line-107"></span><span class="hs-comment">--   will parse only the record-syntax form, and furthermore, the fields</span><span>
</span><span id="line-108"></span><span class="hs-comment">--   must be given in the same order as the original declaration.</span><span>
</span><span id="line-109"></span><span class="hs-comment">--</span><span>
</span><span id="line-110"></span><span class="hs-comment">-- * The derived 'Read' instance allows arbitrary Haskell whitespace</span><span>
</span><span id="line-111"></span><span class="hs-comment">--   between tokens of the input string.  Extra parentheses are also</span><span>
</span><span id="line-112"></span><span class="hs-comment">--   allowed.</span><span>
</span><span id="line-113"></span><span class="hs-comment">--</span><span>
</span><span id="line-114"></span><span class="hs-comment">-- For example, given the declarations</span><span>
</span><span id="line-115"></span><span class="hs-comment">--</span><span>
</span><span id="line-116"></span><span class="hs-comment">-- &gt; infixr 5 :^:</span><span>
</span><span id="line-117"></span><span class="hs-comment">-- &gt; data Tree a =  Leaf a  |  Tree a :^: Tree a</span><span>
</span><span id="line-118"></span><span class="hs-comment">--</span><span>
</span><span id="line-119"></span><span class="hs-comment">-- the derived instance of 'Read' in Haskell 2010 is equivalent to</span><span>
</span><span id="line-120"></span><span class="hs-comment">--</span><span>
</span><span id="line-121"></span><span class="hs-comment">-- &gt; instance (Read a) =&gt; Read (Tree a) where</span><span>
</span><span id="line-122"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-123"></span><span class="hs-comment">-- &gt;         readsPrec d r =  readParen (d &gt; app_prec)</span><span>
</span><span id="line-124"></span><span class="hs-comment">-- &gt;                          (\r -&gt; [(Leaf m,t) |</span><span>
</span><span id="line-125"></span><span class="hs-comment">-- &gt;                                  (&quot;Leaf&quot;,s) &lt;- lex r,</span><span>
</span><span id="line-126"></span><span class="hs-comment">-- &gt;                                  (m,t) &lt;- readsPrec (app_prec+1) s]) r</span><span>
</span><span id="line-127"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-128"></span><span class="hs-comment">-- &gt;                       ++ readParen (d &gt; up_prec)</span><span>
</span><span id="line-129"></span><span class="hs-comment">-- &gt;                          (\r -&gt; [(u:^:v,w) |</span><span>
</span><span id="line-130"></span><span class="hs-comment">-- &gt;                                  (u,s) &lt;- readsPrec (up_prec+1) r,</span><span>
</span><span id="line-131"></span><span class="hs-comment">-- &gt;                                  (&quot;:^:&quot;,t) &lt;- lex s,</span><span>
</span><span id="line-132"></span><span class="hs-comment">-- &gt;                                  (v,w) &lt;- readsPrec (up_prec+1) t]) r</span><span>
</span><span id="line-133"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-134"></span><span class="hs-comment">-- &gt;           where app_prec = 10</span><span>
</span><span id="line-135"></span><span class="hs-comment">-- &gt;                 up_prec = 5</span><span>
</span><span id="line-136"></span><span class="hs-comment">--</span><span>
</span><span id="line-137"></span><span class="hs-comment">-- Note that right-associativity of @:^:@ is unused.</span><span>
</span><span id="line-138"></span><span class="hs-comment">--</span><span>
</span><span id="line-139"></span><span class="hs-comment">-- The derived instance in GHC is equivalent to</span><span>
</span><span id="line-140"></span><span class="hs-comment">--</span><span>
</span><span id="line-141"></span><span class="hs-comment">-- &gt; instance (Read a) =&gt; Read (Tree a) where</span><span>
</span><span id="line-142"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-143"></span><span class="hs-comment">-- &gt;         readPrec = parens $ (prec app_prec $ do</span><span>
</span><span id="line-144"></span><span class="hs-comment">-- &gt;                                  Ident &quot;Leaf&quot; &lt;- lexP</span><span>
</span><span id="line-145"></span><span class="hs-comment">-- &gt;                                  m &lt;- step readPrec</span><span>
</span><span id="line-146"></span><span class="hs-comment">-- &gt;                                  return (Leaf m))</span><span>
</span><span id="line-147"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-148"></span><span class="hs-comment">-- &gt;                      +++ (prec up_prec $ do</span><span>
</span><span id="line-149"></span><span class="hs-comment">-- &gt;                                  u &lt;- step readPrec</span><span>
</span><span id="line-150"></span><span class="hs-comment">-- &gt;                                  Symbol &quot;:^:&quot; &lt;- lexP</span><span>
</span><span id="line-151"></span><span class="hs-comment">-- &gt;                                  v &lt;- step readPrec</span><span>
</span><span id="line-152"></span><span class="hs-comment">-- &gt;                                  return (u :^: v))</span><span>
</span><span id="line-153"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-154"></span><span class="hs-comment">-- &gt;           where app_prec = 10</span><span>
</span><span id="line-155"></span><span class="hs-comment">-- &gt;                 up_prec = 5</span><span>
</span><span id="line-156"></span><span class="hs-comment">-- &gt;</span><span>
</span><span id="line-157"></span><span class="hs-comment">-- &gt;         readListPrec = readListPrecDefault</span><span>
</span><span id="line-158"></span><span class="hs-comment">--</span><span>
</span><span id="line-159"></span><span class="hs-comment">-- Why do both 'readsPrec' and 'readPrec' exist, and why does GHC opt to</span><span>
</span><span id="line-160"></span><span class="hs-comment">-- implement 'readPrec' in derived 'Read' instances instead of 'readsPrec'?</span><span>
</span><span id="line-161"></span><span class="hs-comment">-- The reason is that 'readsPrec' is based on the 'ReadS' type, and although</span><span>
</span><span id="line-162"></span><span class="hs-comment">-- 'ReadS' is mentioned in the Haskell 2010 Report, it is not a very efficient</span><span>
</span><span id="line-163"></span><span class="hs-comment">-- parser data structure.</span><span>
</span><span id="line-164"></span><span class="hs-comment">--</span><span>
</span><span id="line-165"></span><span class="hs-comment">-- 'readPrec', on the other hand, is based on a much more efficient 'ReadPrec'</span><span>
</span><span id="line-166"></span><span class="hs-comment">-- datatype (a.k.a \&quot;new-style parsers\&quot;), but its definition relies on the use</span><span>
</span><span id="line-167"></span><span class="hs-comment">-- of the @RankNTypes@ language extension. Therefore, 'readPrec' (and its</span><span>
</span><span id="line-168"></span><span class="hs-comment">-- cousin, 'readListPrec') are marked as GHC-only. Nevertheless, it is</span><span>
</span><span id="line-169"></span><span class="hs-comment">-- recommended to use 'readPrec' instead of 'readsPrec' whenever possible</span><span>
</span><span id="line-170"></span><span class="hs-comment">-- for the efficiency improvements it brings.</span><span>
</span><span id="line-171"></span><span class="hs-comment">--</span><span>
</span><span id="line-172"></span><span class="hs-comment">-- As mentioned above, derived 'Read' instances in GHC will implement</span><span>
</span><span id="line-173"></span><span class="hs-comment">-- 'readPrec' instead of 'readsPrec'. The default implementations of</span><span>
</span><span id="line-174"></span><span class="hs-comment">-- 'readsPrec' (and its cousin, 'readList') will simply use 'readPrec' under</span><span>
</span><span id="line-175"></span><span class="hs-comment">-- the hood. If you are writing a 'Read' instance by hand, it is recommended</span><span>
</span><span id="line-176"></span><span class="hs-comment">-- to write it like so:</span><span>
</span><span id="line-177"></span><span class="hs-comment">--</span><span>
</span><span id="line-178"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-179"></span><span class="hs-comment">-- instance 'Read' T where</span><span>
</span><span id="line-180"></span><span class="hs-comment">--   'readPrec'     = ...</span><span>
</span><span id="line-181"></span><span class="hs-comment">--   'readListPrec' = 'readListPrecDefault'</span><span>
</span><span id="line-182"></span><span class="hs-comment">-- @</span><span>
</span><span id="line-183"></span><span>
</span><span id="line-184"></span><span class="hs-keyword">class</span><span> </span><span id="Read"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-var">Read</span></a></span></span><span> </span><span id="local-6989586621679495937"><span class="annot"><a href="#local-6989586621679495937"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-185"></span><span>  </span><span class="hs-pragma">{-# MINIMAL</span><span> </span><span class="annot"><a href="GHC.Read.html#readsPrec"><span class="hs-pragma hs-type">readsPrec</span></a></span><span> </span><span class="hs-pragma">|</span><span> </span><span class="annot"><a href="GHC.Read.html#readPrec"><span class="hs-pragma hs-type">readPrec</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-186"></span><span>
</span><span id="line-187"></span><span>  </span><span class="hs-comment">-- | attempts to parse a value from the front of the string, returning</span><span>
</span><span id="line-188"></span><span>  </span><span class="hs-comment">-- a list of (parsed value, remaining string) pairs.  If there is no</span><span>
</span><span id="line-189"></span><span>  </span><span class="hs-comment">-- successful parse, the returned list is empty.</span><span>
</span><span id="line-190"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-191"></span><span>  </span><span class="hs-comment">-- Derived instances of 'Read' and 'Text.Show.Show' satisfy the following:</span><span>
</span><span id="line-192"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-193"></span><span>  </span><span class="hs-comment">-- * @(x,\&quot;\&quot;)@ is an element of</span><span>
</span><span id="line-194"></span><span>  </span><span class="hs-comment">--   @('readsPrec' d ('Text.Show.showsPrec' d x \&quot;\&quot;))@.</span><span>
</span><span id="line-195"></span><span>  </span><span class="hs-comment">--</span><span>
</span><span id="line-196"></span><span>  </span><span class="hs-comment">-- That is, 'readsPrec' parses the string produced by</span><span>
</span><span id="line-197"></span><span>  </span><span class="hs-comment">-- 'Text.Show.showsPrec', and delivers the value that</span><span>
</span><span id="line-198"></span><span>  </span><span class="hs-comment">-- 'Text.Show.showsPrec' started with.</span><span>
</span><span id="line-199"></span><span>
</span><span id="line-200"></span><span>  </span><span id="readsPrec"><span class="annot"><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-type">readsPrec</span></a></span></span><span>    </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span>   </span><span class="hs-comment">-- ^ the operator precedence of the enclosing</span><span>
</span><span id="line-201"></span><span>                        </span><span class="hs-comment">-- context (a number from @0@ to @11@).</span><span>
</span><span id="line-202"></span><span>                        </span><span class="hs-comment">-- Function application has precedence @10@.</span><span>
</span><span id="line-203"></span><span>                </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495937"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-204"></span><span>
</span><span id="line-205"></span><span>  </span><span class="hs-comment">-- | The method 'readList' is provided to allow the programmer to</span><span>
</span><span id="line-206"></span><span>  </span><span class="hs-comment">-- give a specialised way of parsing lists of values.</span><span>
</span><span id="line-207"></span><span>  </span><span class="hs-comment">-- For example, this is used by the predefined 'Read' instance of</span><span>
</span><span id="line-208"></span><span>  </span><span class="hs-comment">-- the 'Char' type, where values of type 'String' should be are</span><span>
</span><span id="line-209"></span><span>  </span><span class="hs-comment">-- expected to use double quotes, rather than square brackets.</span><span>
</span><span id="line-210"></span><span>  </span><span id="readList"><span class="annot"><a href="GHC.Read.html#readList"><span class="hs-identifier hs-type">readList</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495937"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-211"></span><span>
</span><span id="line-212"></span><span>  </span><span class="hs-comment">-- | Proposed replacement for 'readsPrec' using new-style parsers (GHC only).</span><span>
</span><span id="line-213"></span><span>  </span><span id="readPrec"><span class="annot"><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-type">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495937"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-214"></span><span>
</span><span id="line-215"></span><span>  </span><span class="hs-comment">-- | Proposed replacement for 'readList' using new-style parsers (GHC only).</span><span>
</span><span id="line-216"></span><span>  </span><span class="hs-comment">-- The default definition uses 'readList'.  Instances that define 'readPrec'</span><span>
</span><span id="line-217"></span><span>  </span><span class="hs-comment">-- should also define 'readListPrec' as 'readListPrecDefault'.</span><span>
</span><span id="line-218"></span><span>  </span><span id="readListPrec"><span class="annot"><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-type">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495937"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-219"></span><span>
</span><span id="line-220"></span><span>  </span><span class="hs-comment">-- default definitions</span><span>
</span><span id="line-221"></span><span>  </span><span id="local-6989586621679495456"><span class="annot"><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var hs-var">readsPrec</span></a></span><span>    </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; Int -&gt; ReadS a
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span></span><span>
</span><span id="line-222"></span><span>  </span><span id="local-6989586621679495453"><span class="annot"><a href="GHC.Read.html#readList"><span class="hs-identifier hs-var hs-var">readList</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span></span><span>
</span><span id="line-223"></span><span>  </span><span id="local-6989586621679495451"><span class="annot"><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var hs-var">readPrec</span></a></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS a) -&gt; ReadPrec a
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS a
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span></span><span>
</span><span id="line-224"></span><span>  </span><span id="local-6989586621679495448"><span class="annot"><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var hs-var">readListPrec</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Int -&gt; ReadS [a]) -&gt; ReadPrec [a]
forall a. (Int -&gt; ReadS a) -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#readS_to_Prec"><span class="hs-identifier hs-var">readS_to_Prec</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="annot"><span class="annottext">Int
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadS [a]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readList"><span class="hs-identifier hs-var">readList</span></a></span><span class="hs-special">)</span></span><span>
</span><span id="line-225"></span><span>
</span><span id="line-226"></span><span id="local-6989586621679495446"><span class="annot"><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-type">readListDefault</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495446"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495446"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-227"></span><span class="hs-comment">-- ^ A possible replacement definition for the 'readList' method (GHC only).</span><span>
</span><span id="line-228"></span><span class="hs-comment">--   This is only needed for GHC, and even then only for 'Read' instances</span><span>
</span><span id="line-229"></span><span class="hs-comment">--   where 'readListPrec' isn't defined as 'readListPrecDefault'.</span><span>
</span><span id="line-230"></span><span id="readListDefault"><span class="annot"><span class="annottext">readListDefault :: forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var hs-var">readListDefault</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; Int -&gt; ReadS [a]
forall a. ReadPrec a -&gt; Int -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadPrec.html#readPrec_to_S"><span class="hs-identifier hs-var">readPrec_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><span class="hs-number">0</span></span><span>
</span><span id="line-231"></span><span>
</span><span id="line-232"></span><span id="local-6989586621679495443"><span class="annot"><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-type">readListPrecDefault</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495443"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495443"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-233"></span><span class="hs-comment">-- ^ A possible replacement definition for the 'readListPrec' method,</span><span>
</span><span id="line-234"></span><span class="hs-comment">--   defined using 'readPrec' (GHC only).</span><span>
</span><span id="line-235"></span><span id="readListPrecDefault"><span class="annot"><span class="annottext">readListPrecDefault :: forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var hs-var">readListPrecDefault</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec [a]
forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var">list</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-236"></span><span>
</span><span id="line-237"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-238"></span><span class="hs-comment">-- H2010 compatibility</span><span>
</span><span id="line-239"></span><span>
</span><span id="line-240"></span><span class="hs-comment">-- | The 'lex' function reads a single lexeme from the input, discarding</span><span>
</span><span id="line-241"></span><span class="hs-comment">-- initial white space, and returning the characters that constitute the</span><span>
</span><span id="line-242"></span><span class="hs-comment">-- lexeme.  If the input string contains only white space, 'lex' returns a</span><span>
</span><span id="line-243"></span><span class="hs-comment">-- single successful \`lexeme\' consisting of the empty string.  (Thus</span><span>
</span><span id="line-244"></span><span class="hs-comment">-- @'lex' \&quot;\&quot; = [(\&quot;\&quot;,\&quot;\&quot;)]@.)  If there is no legal lexeme at the</span><span>
</span><span id="line-245"></span><span class="hs-comment">-- beginning of the input string, 'lex' fails (i.e. returns @[]@).</span><span>
</span><span id="line-246"></span><span class="hs-comment">--</span><span>
</span><span id="line-247"></span><span class="hs-comment">-- This lexer is not completely faithful to the Haskell lexical syntax</span><span>
</span><span id="line-248"></span><span class="hs-comment">-- in the following respects:</span><span>
</span><span id="line-249"></span><span class="hs-comment">--</span><span>
</span><span id="line-250"></span><span class="hs-comment">-- * Qualified names are not handled properly</span><span>
</span><span id="line-251"></span><span class="hs-comment">--</span><span>
</span><span id="line-252"></span><span class="hs-comment">-- * Octal and hexadecimal numerics are not recognized as a single token</span><span>
</span><span id="line-253"></span><span class="hs-comment">--</span><span>
</span><span id="line-254"></span><span class="hs-comment">-- * Comments are not treated properly</span><span>
</span><span id="line-255"></span><span class="annot"><a href="GHC.Read.html#lex"><span class="hs-identifier hs-type">lex</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>             </span><span class="hs-comment">-- As defined by H2010</span><span>
</span><span id="line-256"></span><span id="lex"><span class="annot"><span class="annottext">lex :: ReadS String
</span><a href="GHC.Read.html#lex"><span class="hs-identifier hs-var hs-var">lex</span></a></span></span><span> </span><span id="local-6989586621679495440"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495440"><span class="hs-identifier hs-var">s</span></a></span></span><span>  </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP String -&gt; ReadS String
forall a. ReadP a -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadP.html#readP_to_S"><span class="hs-identifier hs-var">readP_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadP String
</span><a href="Text.Read.Lex.html#hsLex"><span class="hs-identifier hs-var">L.hsLex</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495440"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-257"></span><span>
</span><span id="line-258"></span><span class="hs-comment">-- | Read a string representation of a character, using Haskell</span><span>
</span><span id="line-259"></span><span class="hs-comment">-- source-language escape conventions.  For example:</span><span>
</span><span id="line-260"></span><span class="hs-comment">--</span><span>
</span><span id="line-261"></span><span class="hs-comment">-- &gt; lexLitChar  &quot;\\nHello&quot;  =  [(&quot;\\n&quot;, &quot;Hello&quot;)]</span><span>
</span><span id="line-262"></span><span class="hs-comment">--</span><span>
</span><span id="line-263"></span><span class="annot"><a href="GHC.Read.html#lexLitChar"><span class="hs-identifier hs-type">lexLitChar</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>      </span><span class="hs-comment">-- As defined by H2010</span><span>
</span><span id="line-264"></span><span id="lexLitChar"><span class="annot"><span class="annottext">lexLitChar :: ReadS String
</span><a href="GHC.Read.html#lexLitChar"><span class="hs-identifier hs-var hs-var">lexLitChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP String -&gt; ReadS String
forall a. ReadP a -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadP.html#readP_to_S"><span class="hs-identifier hs-var">readP_to_S</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495438"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495438"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadP Char -&gt; ReadP (String, Char)
forall a. ReadP a -&gt; ReadP (String, a)
</span><a href="Text.ParserCombinators.ReadP.html#gather"><span class="hs-identifier hs-var">P.gather</span></a></span><span> </span><span class="annot"><span class="annottext">ReadP Char
</span><a href="Text.Read.Lex.html#lexChar"><span class="hs-identifier hs-var">L.lexChar</span></a></span><span> </span><span class="hs-special">;</span><span>
</span><span id="line-265"></span><span>                              </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679495435"><span class="annot"><span class="annottext">s' :: String
</span><a href="#local-6989586621679495435"><span class="hs-identifier hs-var hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String
</span><a href="#local-6989586621679495434"><span class="hs-identifier hs-var">removeNulls</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495438"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-keyword">in</span><span>
</span><span id="line-266"></span><span>                              </span><span class="annot"><span class="annottext">String -&gt; ReadP String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495435"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-267"></span><span>    </span><span class="hs-keyword">where</span><span>
</span><span id="line-268"></span><span>    </span><span class="hs-comment">-- remove nulls from end of the character if they exist</span><span>
</span><span id="line-269"></span><span>    </span><span id="local-6989586621679495434"><span class="annot"><span class="annottext">removeNulls :: String -&gt; String
</span><a href="#local-6989586621679495434"><span class="hs-identifier hs-var hs-var">removeNulls</span></a></span></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-270"></span><span>    </span><span class="annot"><a href="#local-6989586621679495434"><span class="hs-identifier hs-var">removeNulls</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'\\'</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'&amp;'</span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679495433"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495433"><span class="hs-identifier hs-var">xs</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">String -&gt; String
</span><a href="#local-6989586621679495434"><span class="hs-identifier hs-var">removeNulls</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495433"><span class="hs-identifier hs-var">xs</span></a></span><span>
</span><span id="line-271"></span><span>    </span><span class="annot"><a href="#local-6989586621679495434"><span class="hs-identifier hs-var">removeNulls</span></a></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495432"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495432"><span class="hs-identifier hs-var">first</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679495431"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495431"><span class="hs-identifier hs-var">rest</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495432"><span class="hs-identifier hs-var">first</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; String -&gt; String
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; String
</span><a href="#local-6989586621679495434"><span class="hs-identifier hs-var">removeNulls</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495431"><span class="hs-identifier hs-var">rest</span></a></span><span>
</span><span id="line-272"></span><span>        </span><span class="hs-comment">-- There was a skipSpaces before the P.gather L.lexChar,</span><span>
</span><span id="line-273"></span><span>        </span><span class="hs-comment">-- but that seems inconsistent with readLitChar</span><span>
</span><span id="line-274"></span><span>
</span><span id="line-275"></span><span class="hs-comment">-- | Read a string representation of a character, using Haskell</span><span>
</span><span id="line-276"></span><span class="hs-comment">-- source-language escape conventions, and convert it to the character</span><span>
</span><span id="line-277"></span><span class="hs-comment">-- that it encodes.  For example:</span><span>
</span><span id="line-278"></span><span class="hs-comment">--</span><span>
</span><span id="line-279"></span><span class="hs-comment">-- &gt; readLitChar &quot;\\nHello&quot;  =  [('\n', &quot;Hello&quot;)]</span><span>
</span><span id="line-280"></span><span class="hs-comment">--</span><span>
</span><span id="line-281"></span><span class="annot"><a href="GHC.Read.html#readLitChar"><span class="hs-identifier hs-type">readLitChar</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span>       </span><span class="hs-comment">-- As defined by H2010</span><span>
</span><span id="line-282"></span><span id="readLitChar"><span class="annot"><span class="annottext">readLitChar :: ReadS Char
</span><a href="GHC.Read.html#readLitChar"><span class="hs-identifier hs-var hs-var">readLitChar</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP Char -&gt; ReadS Char
forall a. ReadP a -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadP.html#readP_to_S"><span class="hs-identifier hs-var">readP_to_S</span></a></span><span> </span><span class="annot"><span class="annottext">ReadP Char
</span><a href="Text.Read.Lex.html#lexChar"><span class="hs-identifier hs-var">L.lexChar</span></a></span><span>
</span><span id="line-283"></span><span>
</span><span id="line-284"></span><span class="hs-comment">-- | Reads a non-empty string of decimal digits.</span><span>
</span><span id="line-285"></span><span class="annot"><a href="GHC.Read.html#lexDigits"><span class="hs-identifier hs-type">lexDigits</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadP.html#ReadS"><span class="hs-identifier hs-type">ReadS</span></a></span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span>
</span><span id="line-286"></span><span id="lexDigits"><span class="annot"><span class="annottext">lexDigits :: ReadS String
</span><a href="GHC.Read.html#lexDigits"><span class="hs-identifier hs-var hs-var">lexDigits</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP String -&gt; ReadS String
forall a. ReadP a -&gt; ReadS a
</span><a href="Text.ParserCombinators.ReadP.html#readP_to_S"><span class="hs-identifier hs-var">readP_to_S</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(Char -&gt; Bool) -&gt; ReadP String
</span><a href="Text.ParserCombinators.ReadP.html#munch1"><span class="hs-identifier hs-var">P.munch1</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="GHC.Unicode.html#isDigit"><span class="hs-identifier hs-var">isDigit</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-287"></span><span>
</span><span id="line-288"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-289"></span><span class="hs-comment">-- utility parsers</span><span>
</span><span id="line-290"></span><span>
</span><span id="line-291"></span><span class="annot"><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-type">lexP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span><span>
</span><span id="line-292"></span><span class="hs-comment">-- ^ Parse a single lexeme</span><span>
</span><span id="line-293"></span><span id="lexP"><span class="annot"><span class="annottext">lexP :: ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var hs-var">lexP</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP Lexeme -&gt; ReadPrec Lexeme
forall a. ReadP a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="annot"><span class="annottext">ReadP Lexeme
</span><a href="Text.Read.Lex.html#lex"><span class="hs-identifier hs-var">L.lex</span></a></span><span>
</span><span id="line-294"></span><span>
</span><span id="line-295"></span><span class="annot"><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-type">expectP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-296"></span><span id="expectP"><span class="annot"><span class="annottext">expectP :: Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var hs-var">expectP</span></a></span></span><span> </span><span id="local-6989586621679495426"><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495426"><span class="hs-identifier hs-var">lexeme</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadP () -&gt; ReadPrec ()
forall a. ReadP a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#lift"><span class="hs-identifier hs-var">lift</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Lexeme -&gt; ReadP ()
</span><a href="Text.Read.Lex.html#expect"><span class="hs-identifier hs-var">L.expect</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495426"><span class="hs-identifier hs-var">lexeme</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-297"></span><span>
</span><span id="line-298"></span><span id="local-6989586621679495926"><span class="annot"><a href="GHC.Read.html#expectCharP"><span class="hs-identifier hs-type">expectCharP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495926"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495926"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-299"></span><span id="expectCharP"><span class="annot"><span class="annottext">expectCharP :: forall a. Char -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#expectCharP"><span class="hs-identifier hs-var hs-var">expectCharP</span></a></span></span><span> </span><span id="local-6989586621679495419"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495419"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span id="local-6989586621679495418"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495418"><span class="hs-identifier hs-var">a</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-300"></span><span>  </span><span id="local-6989586621679495417"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495417"><span class="hs-identifier hs-var">q</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Char
</span><a href="Text.ParserCombinators.ReadPrec.html#get"><span class="hs-identifier hs-var">get</span></a></span><span>
</span><span id="line-301"></span><span>  </span><span class="hs-keyword">if</span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495417"><span class="hs-identifier hs-var">q</span></a></span><span> </span><span class="annot"><span class="annottext">Char -&gt; Char -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495419"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-302"></span><span>    </span><span class="hs-keyword">then</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495418"><span class="hs-identifier hs-var">a</span></a></span><span>
</span><span id="line-303"></span><span>    </span><span class="hs-keyword">else</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-304"></span><span class="hs-pragma">{-# INLINE</span><span> </span><span class="annot"><a href="GHC.Read.html#expectCharP"><span class="hs-pragma hs-type">expectCharP</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-305"></span><span>
</span><span id="line-306"></span><span id="local-6989586621679495922"><span class="annot"><a href="GHC.Read.html#skipSpacesThenP"><span class="hs-identifier hs-type">skipSpacesThenP</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495922"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495922"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-307"></span><span id="skipSpacesThenP"><span class="annot"><span class="annottext">skipSpacesThenP :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#skipSpacesThenP"><span class="hs-identifier hs-var hs-var">skipSpacesThenP</span></a></span></span><span> </span><span id="local-6989586621679495412"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495412"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-308"></span><span>  </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679495411"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495411"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec String
</span><a href="Text.ParserCombinators.ReadPrec.html#look"><span class="hs-identifier hs-var">look</span></a></span><span>
</span><span id="line-309"></span><span>     </span><span class="annot"><span class="annottext">String -&gt; ReadPrec a
</span><a href="#local-6989586621679495409"><span class="hs-identifier hs-var">skip</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495411"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-310"></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-311"></span><span>   </span><span id="local-6989586621679495409"><span class="annot"><span class="annottext">skip :: String -&gt; ReadPrec a
</span><a href="#local-6989586621679495409"><span class="hs-identifier hs-var hs-var">skip</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495406"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495406"><span class="hs-identifier hs-var">c</span></a></span></span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-type">:</span></a></span><span id="local-6989586621679495405"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495405"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Char -&gt; Bool
</span><a href="GHC.Unicode.html#isSpace"><span class="hs-identifier hs-var">isSpace</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495406"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec Char
</span><a href="Text.ParserCombinators.ReadPrec.html#get"><span class="hs-identifier hs-var">get</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec Char -&gt; ReadPrec a -&gt; ReadPrec a
forall (f :: * -&gt; *) a b. Applicative f =&gt; f a -&gt; f b -&gt; f b
</span><a href="GHC.Base.html#%2A%3E"><span class="hs-operator hs-var">*&gt;</span></a></span><span> </span><span class="annot"><span class="annottext">String -&gt; ReadPrec a
</span><a href="#local-6989586621679495409"><span class="hs-identifier hs-var">skip</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495405"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-312"></span><span>   </span><span class="annot"><a href="#local-6989586621679495409"><span class="hs-identifier hs-var">skip</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495412"><span class="hs-identifier hs-var">m</span></a></span><span>
</span><span id="line-313"></span><span>
</span><span id="line-314"></span><span id="local-6989586621679495403"><span class="annot"><a href="GHC.Read.html#paren"><span class="hs-identifier hs-type">paren</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495403"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495403"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-315"></span><span class="hs-comment">-- ^ @(paren p)@ parses \&quot;(P0)\&quot;</span><span>
</span><span id="line-316"></span><span class="hs-comment">--      where @p@ parses \&quot;P0\&quot; in precedence context zero</span><span>
</span><span id="line-317"></span><span id="paren"><span class="annot"><span class="annottext">paren :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren"><span class="hs-identifier hs-var hs-var">paren</span></a></span></span><span> </span><span id="local-6989586621679495402"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495402"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#skipSpacesThenP"><span class="hs-identifier hs-var">skipSpacesThenP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren%27"><span class="hs-identifier hs-var">paren'</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495402"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-318"></span><span>
</span><span id="line-319"></span><span id="local-6989586621679495400"><span class="annot"><a href="GHC.Read.html#paren%27"><span class="hs-identifier hs-type">paren'</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495400"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495400"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-320"></span><span id="paren%27"><span class="annot"><span class="annottext">paren' :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren%27"><span class="hs-identifier hs-var hs-var">paren'</span></a></span></span><span> </span><span id="local-6989586621679495397"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495397"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Char -&gt; ReadPrec a -&gt; ReadPrec a
forall a. Char -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#expectCharP"><span class="hs-identifier hs-var">expectCharP</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">'('</span></span><span> </span><span class="annot"><span class="annottext">(ReadPrec a -&gt; ReadPrec a) -&gt; ReadPrec a -&gt; ReadPrec a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#reset"><span class="hs-identifier hs-var">reset</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495397"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; (a -&gt; ReadPrec a) -&gt; ReadPrec a
forall (m :: * -&gt; *) a b. Monad m =&gt; m a -&gt; (a -&gt; m b) -&gt; m b
</span><a href="GHC.Base.html#%3E%3E%3D"><span class="hs-operator hs-var">&gt;&gt;=</span></a></span><span> </span><span class="hs-glyph">\</span><span id="local-6989586621679495395"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495395"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span>
</span><span id="line-321"></span><span>              </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#skipSpacesThenP"><span class="hs-identifier hs-var">skipSpacesThenP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Char -&gt; ReadPrec a -&gt; ReadPrec a
forall a. Char -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#expectCharP"><span class="hs-identifier hs-var">expectCharP</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><span class="hs-char">')'</span></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (f :: * -&gt; *) a. Applicative f =&gt; a -&gt; f a
</span><a href="GHC.Base.html#pure"><span class="hs-identifier hs-var">pure</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495395"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-322"></span><span>
</span><span id="line-323"></span><span id="local-6989586621679495394"><span class="annot"><a href="GHC.Read.html#parens"><span class="hs-identifier hs-type">parens</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495394"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495394"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-324"></span><span class="hs-comment">-- ^ @(parens p)@ parses \&quot;P\&quot;, \&quot;(P0)\&quot;, \&quot;((P0))\&quot;, etc,</span><span>
</span><span id="line-325"></span><span class="hs-comment">--      where @p@ parses \&quot;P\&quot;  in the current precedence context</span><span>
</span><span id="line-326"></span><span class="hs-comment">--          and parses \&quot;P0\&quot; in precedence context zero</span><span>
</span><span id="line-327"></span><span id="parens"><span class="annot"><span class="annottext">parens :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var hs-var">parens</span></a></span></span><span> </span><span id="local-6989586621679495393"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495393"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495392"><span class="hs-identifier hs-var">optional</span></a></span><span>
</span><span id="line-328"></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-329"></span><span>    </span><span id="local-6989586621679495392"><span class="annot"><span class="annottext">optional :: ReadPrec a
</span><a href="#local-6989586621679495392"><span class="hs-identifier hs-var hs-var">optional</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#skipSpacesThenP"><span class="hs-identifier hs-var">skipSpacesThenP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495393"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#%2B%2B%2B"><span class="hs-operator hs-var">+++</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495390"><span class="hs-identifier hs-var">mandatory</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-330"></span><span>    </span><span id="local-6989586621679495390"><span class="annot"><span class="annottext">mandatory :: ReadPrec a
</span><a href="#local-6989586621679495390"><span class="hs-identifier hs-var hs-var">mandatory</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren%27"><span class="hs-identifier hs-var">paren'</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495392"><span class="hs-identifier hs-var">optional</span></a></span><span>
</span><span id="line-331"></span><span>
</span><span id="line-332"></span><span id="local-6989586621679495934"><span class="annot"><a href="GHC.Read.html#list"><span class="hs-identifier hs-type">list</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495934"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495934"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span>
</span><span id="line-333"></span><span class="hs-comment">-- ^ @(list p)@ parses a list of things parsed by @p@,</span><span>
</span><span id="line-334"></span><span class="hs-comment">-- using the usual square-bracket syntax.</span><span>
</span><span id="line-335"></span><span id="list"><span class="annot"><span class="annottext">list :: forall a. ReadPrec a -&gt; ReadPrec [a]
</span><a href="GHC.Read.html#list"><span class="hs-identifier hs-var hs-var">list</span></a></span></span><span> </span><span id="local-6989586621679495388"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495388"><span class="hs-identifier hs-var">readx</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-336"></span><span>  </span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; ReadPrec [a]
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-337"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;[&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-338"></span><span>       </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Bool -&gt; ReadPrec [a]
</span><a href="#local-6989586621679495386"><span class="hs-identifier hs-var">listRest</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a] -&gt; ReadPrec [a] -&gt; ReadPrec [a]
forall a. ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#%2B%2B%2B"><span class="hs-operator hs-var">+++</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679495385"><span class="hs-identifier hs-var">listNext</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-339"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-340"></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-341"></span><span>  </span><span id="local-6989586621679495386"><span class="annot"><span class="annottext">listRest :: Bool -&gt; ReadPrec [a]
</span><a href="#local-6989586621679495386"><span class="hs-identifier hs-var hs-var">listRest</span></a></span></span><span> </span><span id="local-6989586621679495377"><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679495377"><span class="hs-identifier hs-var">started</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-342"></span><span>    </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-type">L.Punc</span></a></span><span> </span><span id="local-6989586621679495376"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495376"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-343"></span><span>       </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495376"><span class="hs-identifier hs-var">c</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-344"></span><span>         </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;]&quot;</span></span><span>           </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">[a] -&gt; ReadPrec [a]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">[</span><span class="hs-special">]</span><span>
</span><span id="line-345"></span><span>         </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;,&quot;</span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="#local-6989586621679495377"><span class="hs-identifier hs-var">started</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
</span><a href="#local-6989586621679495385"><span class="hs-identifier hs-var">listNext</span></a></span><span>
</span><span id="line-346"></span><span>         </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span>             </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-347"></span><span>
</span><span id="line-348"></span><span>  </span><span id="local-6989586621679495385"><span class="annot"><span class="annottext">listNext :: ReadPrec [a]
</span><a href="#local-6989586621679495385"><span class="hs-identifier hs-var hs-var">listNext</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-349"></span><span>    </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679495375"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495375"><span class="hs-identifier hs-var">x</span></a></span></span><span>  </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#reset"><span class="hs-identifier hs-var">reset</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495388"><span class="hs-identifier hs-var">readx</span></a></span><span>
</span><span id="line-350"></span><span>       </span><span id="local-6989586621679495374"><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679495374"><span class="hs-identifier hs-var">xs</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ReadPrec [a]
</span><a href="#local-6989586621679495386"><span class="hs-identifier hs-var">listRest</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span><span>
</span><span id="line-351"></span><span>       </span><span class="annot"><span class="annottext">[a] -&gt; ReadPrec [a]
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495375"><span class="hs-identifier hs-var">x</span></a></span><span class="annot"><span class="annottext">a -&gt; [a] -&gt; [a]
forall a. a -&gt; [a] -&gt; [a]
</span><a href="../../ghc-prim/src/GHC.Types.html#%3A"><span class="hs-glyph hs-var">:</span></a></span><span class="annot"><span class="annottext">[a]
</span><a href="#local-6989586621679495374"><span class="hs-identifier hs-var">xs</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-352"></span><span>
</span><span id="line-353"></span><span id="local-6989586621679495906"><span class="annot"><a href="GHC.Read.html#choose"><span class="hs-identifier hs-type">choose</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495906"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span class="hs-special">]</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495906"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-354"></span><span class="hs-comment">-- ^ Parse the specified lexeme and continue as specified.</span><span>
</span><span id="line-355"></span><span class="hs-comment">-- Esp useful for nullary constructors; e.g.</span><span>
</span><span id="line-356"></span><span class="hs-comment">--    @choose [(\&quot;A\&quot;, return A), (\&quot;B\&quot;, return B)]@</span><span>
</span><span id="line-357"></span><span class="hs-comment">-- We match both Ident and Symbol because the constructor</span><span>
</span><span id="line-358"></span><span class="hs-comment">-- might be an operator eg @(:~:)@</span><span>
</span><span id="line-359"></span><span id="choose"><span class="annot"><span class="annottext">choose :: forall a. [(String, ReadPrec a)] -&gt; ReadPrec a
</span><a href="GHC.Read.html#choose"><span class="hs-identifier hs-var hs-var">choose</span></a></span></span><span> </span><span id="local-6989586621679495373"><span class="annot"><span class="annottext">[(String, ReadPrec a)]
</span><a href="#local-6989586621679495373"><span class="hs-identifier hs-var">sps</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((String, ReadPrec a) -&gt; ReadPrec a -&gt; ReadPrec a)
-&gt; ReadPrec a -&gt; [(String, ReadPrec a)] -&gt; ReadPrec a
forall a b. (a -&gt; b -&gt; b) -&gt; b -&gt; [a] -&gt; b
</span><a href="GHC.Base.html#foldr"><span class="hs-identifier hs-var">foldr</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#%2B%2B%2B"><span class="hs-operator hs-var">(+++)</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a)
-&gt; ((String, ReadPrec a) -&gt; ReadPrec a)
-&gt; (String, ReadPrec a)
-&gt; ReadPrec a
-&gt; ReadPrec a
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">(String, ReadPrec a) -&gt; ReadPrec a
forall {b}. (String, ReadPrec b) -&gt; ReadPrec b
</span><a href="#local-6989586621679495371"><span class="hs-identifier hs-var">try_one</span></a></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span> </span><span class="annot"><span class="annottext">[(String, ReadPrec a)]
</span><a href="#local-6989586621679495373"><span class="hs-identifier hs-var">sps</span></a></span><span>
</span><span id="line-360"></span><span>           </span><span class="hs-keyword">where</span><span>
</span><span id="line-361"></span><span>             </span><span id="local-6989586621679495371"><span class="annot"><span class="annottext">try_one :: (String, ReadPrec b) -&gt; ReadPrec b
</span><a href="#local-6989586621679495371"><span class="hs-identifier hs-var hs-var">try_one</span></a></span></span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495365"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495365"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679495364"><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679495364"><span class="hs-identifier hs-var">p</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span id="local-6989586621679495363"><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495363"><span class="hs-identifier hs-var">token</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span> </span><span class="hs-special">;</span><span>
</span><span id="line-362"></span><span>                                  </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495363"><span class="hs-identifier hs-var">token</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-363"></span><span>                                    </span><span class="annot"><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-type">L.Ident</span></a></span><span> </span><span id="local-6989586621679495361"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495361"><span class="hs-identifier hs-var">s'</span></a></span></span><span>  </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495365"><span class="hs-identifier hs-var">s</span></a></span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495361"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679495364"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-364"></span><span>                                    </span><span class="annot"><a href="Text.Read.Lex.html#Symbol"><span class="hs-identifier hs-type">L.Symbol</span></a></span><span> </span><span id="local-6989586621679495359"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495359"><span class="hs-identifier hs-var">s'</span></a></span></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495365"><span class="hs-identifier hs-var">s</span></a></span><span class="annot"><span class="annottext">String -&gt; String -&gt; Bool
forall a. Eq a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3D%3D"><span class="hs-operator hs-var">==</span></a></span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495359"><span class="hs-identifier hs-var">s'</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec b
</span><a href="#local-6989586621679495364"><span class="hs-identifier hs-var">p</span></a></span><span>
</span><span id="line-365"></span><span>                                    </span><span id="local-6989586621679495358"><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495358"><span class="hs-identifier hs-var">_other</span></a></span></span><span>              </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec b
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span> </span><span class="hs-special">}</span><span>
</span><span id="line-366"></span><span>
</span><span id="line-367"></span><span class="hs-comment">-- See Note [Why readField]</span><span>
</span><span id="line-368"></span><span>
</span><span id="line-369"></span><span class="hs-comment">-- | 'Read' parser for a record field, of the form @fieldName=value@. The</span><span>
</span><span id="line-370"></span><span class="hs-comment">-- @fieldName@ must be an alphanumeric identifier; for symbols (operator-style)</span><span>
</span><span id="line-371"></span><span class="hs-comment">-- field names, e.g. @(#)@, use 'readSymField'). The second argument is a</span><span>
</span><span id="line-372"></span><span class="hs-comment">-- parser for the field value.</span><span>
</span><span id="line-373"></span><span id="local-6989586621679495897"><span class="annot"><a href="GHC.Read.html#readField"><span class="hs-identifier hs-type">readField</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495897"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495897"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-374"></span><span id="readField"><span class="annot"><span class="annottext">readField :: forall a. String -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#readField"><span class="hs-identifier hs-var hs-var">readField</span></a></span></span><span> </span><span id="local-6989586621679495355"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495355"><span class="hs-identifier hs-var">fieldName</span></a></span></span><span> </span><span id="local-6989586621679495354"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495354"><span class="hs-identifier hs-var">readVal</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-375"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495355"><span class="hs-identifier hs-var">fieldName</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-376"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;=&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-377"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495354"><span class="hs-identifier hs-var">readVal</span></a></span><span>
</span><span id="line-378"></span><span class="hs-pragma">{-# NOINLINE</span><span> </span><span class="annot"><a href="GHC.Read.html#readField"><span class="hs-pragma hs-type">readField</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-379"></span><span>
</span><span id="line-380"></span><span class="hs-comment">-- See Note [Why readField]</span><span>
</span><span id="line-381"></span><span>
</span><span id="line-382"></span><span class="hs-comment">-- | 'Read' parser for a record field, of the form @fieldName#=value@. That is,</span><span>
</span><span id="line-383"></span><span class="hs-comment">-- an alphanumeric identifier @fieldName@ followed by the symbol @#@. The</span><span>
</span><span id="line-384"></span><span class="hs-comment">-- second argument is a parser for the field value.</span><span>
</span><span id="line-385"></span><span class="hs-comment">--</span><span>
</span><span id="line-386"></span><span class="hs-comment">-- Note that 'readField' does not suffice for this purpose due to</span><span>
</span><span id="line-387"></span><span class="hs-comment">-- &lt;https://gitlab.haskell.org/ghc/ghc/issues/5041 #5041&gt;.</span><span>
</span><span id="line-388"></span><span id="local-6989586621679495353"><span class="annot"><a href="GHC.Read.html#readFieldHash"><span class="hs-identifier hs-type">readFieldHash</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495353"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495353"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-389"></span><span id="readFieldHash"><span class="annot"><span class="annottext">readFieldHash :: forall a. String -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#readFieldHash"><span class="hs-identifier hs-var hs-var">readFieldHash</span></a></span></span><span> </span><span id="local-6989586621679495349"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495349"><span class="hs-identifier hs-var">fieldName</span></a></span></span><span> </span><span id="local-6989586621679495348"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495348"><span class="hs-identifier hs-var">readVal</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-390"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495349"><span class="hs-identifier hs-var">fieldName</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-391"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Symbol"><span class="hs-identifier hs-var">L.Symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;#&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-392"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;=&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-393"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495348"><span class="hs-identifier hs-var">readVal</span></a></span><span>
</span><span id="line-394"></span><span class="hs-pragma">{-# NOINLINE</span><span> </span><span class="annot"><a href="GHC.Read.html#readFieldHash"><span class="hs-pragma hs-type">readFieldHash</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-395"></span><span>
</span><span id="line-396"></span><span class="hs-comment">-- See Note [Why readField]</span><span>
</span><span id="line-397"></span><span>
</span><span id="line-398"></span><span class="hs-comment">-- | 'Read' parser for a symbol record field, of the form @(###)=value@ (where</span><span>
</span><span id="line-399"></span><span class="hs-comment">-- @###@ is the field name). The field name must be a symbol (operator-style),</span><span>
</span><span id="line-400"></span><span class="hs-comment">-- e.g. @(#)@. For regular (alphanumeric) field names, use 'readField'. The</span><span>
</span><span id="line-401"></span><span class="hs-comment">-- second argument is a parser for the field value.</span><span>
</span><span id="line-402"></span><span id="local-6989586621679495347"><span class="annot"><a href="GHC.Read.html#readSymField"><span class="hs-identifier hs-type">readSymField</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-identifier hs-type">String</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495347"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495347"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-403"></span><span id="readSymField"><span class="annot"><span class="annottext">readSymField :: forall a. String -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#readSymField"><span class="hs-identifier hs-var hs-var">readSymField</span></a></span></span><span> </span><span id="local-6989586621679495342"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495342"><span class="hs-identifier hs-var">fieldName</span></a></span></span><span> </span><span id="local-6989586621679495341"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495341"><span class="hs-identifier hs-var">readVal</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>
</span><span id="line-404"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;(&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-405"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Symbol"><span class="hs-identifier hs-var">L.Symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495342"><span class="hs-identifier hs-var">fieldName</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-406"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;)&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-407"></span><span>        </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;=&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-408"></span><span>        </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679495341"><span class="hs-identifier hs-var">readVal</span></a></span><span>
</span><span id="line-409"></span><span class="hs-pragma">{-# NOINLINE</span><span> </span><span class="annot"><a href="GHC.Read.html#readSymField"><span class="hs-pragma hs-type">readSymField</span></a></span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-410"></span><span>
</span><span id="line-411"></span><span>
</span><span id="line-412"></span><span class="hs-comment">-- Note [Why readField]</span><span>
</span><span id="line-413"></span><span class="hs-comment">--</span><span>
</span><span id="line-414"></span><span class="hs-comment">-- Previously, the code for automatically deriving Read instance (in</span><span>
</span><span id="line-415"></span><span class="hs-comment">-- typecheck/GHC.Tc.Deriv.Generate.hs) would generate inline code for parsing fields;</span><span>
</span><span id="line-416"></span><span class="hs-comment">-- this, however, turned out to produce massive amounts of intermediate code,</span><span>
</span><span id="line-417"></span><span class="hs-comment">-- and produced a considerable performance hit in the code generator.</span><span>
</span><span id="line-418"></span><span class="hs-comment">-- Since Read instances are not generally supposed to be performance critical,</span><span>
</span><span id="line-419"></span><span class="hs-comment">-- the readField and readSymField functions have been factored out, and the</span><span>
</span><span id="line-420"></span><span class="hs-comment">-- code generator now just generates calls rather than manually inlining the</span><span>
</span><span id="line-421"></span><span class="hs-comment">-- parsers. For large record types (e.g. 500 fields), this produces a</span><span>
</span><span id="line-422"></span><span class="hs-comment">-- significant performance boost.</span><span>
</span><span id="line-423"></span><span class="hs-comment">--</span><span>
</span><span id="line-424"></span><span class="hs-comment">-- See also #14364.</span><span>
</span><span id="line-425"></span><span>
</span><span id="line-426"></span><span>
</span><span id="line-427"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-428"></span><span class="hs-comment">-- Simple instances of Read</span><span>
</span><span id="line-429"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-430"></span><span>
</span><span id="line-431"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-432"></span><span id="local-6989586621679495302"><span id="local-6989586621679495334"><span id="local-6989586621679495337"><span id="local-6989586621679495339"><span class="hs-keyword">deriving</span><span> </span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="GHC.Unicode.html#GeneralCategory"><span class="hs-identifier hs-type">GeneralCategory</span></a></span></span></span></span></span><span>
</span><span id="line-433"></span><span>
</span><span id="line-434"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-435"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495298"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-identifier hs-type">Char</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-436"></span><span>  </span><span id="local-6989586621679495291"><span class="annot"><span class="annottext">readPrec :: ReadPrec Char
</span><a href="#local-6989586621679495291"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-437"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec Char -&gt; ReadPrec Char
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-438"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Char"><span class="hs-identifier hs-type">L.Char</span></a></span><span> </span><span id="local-6989586621679495289"><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495289"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-439"></span><span>         </span><span class="annot"><span class="annottext">Char -&gt; ReadPrec Char
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Char
</span><a href="#local-6989586621679495289"><span class="hs-identifier hs-var">c</span></a></span><span>
</span><span id="line-440"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-441"></span><span>
</span><span id="line-442"></span><span>  </span><span id="local-6989586621679495284"><span class="annot"><span class="annottext">readListPrec :: ReadPrec String
</span><a href="#local-6989586621679495284"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-443"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec String -&gt; ReadPrec String
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-444"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#String"><span class="hs-identifier hs-type">L.String</span></a></span><span> </span><span id="local-6989586621679495282"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495282"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>     </span><span class="hs-comment">-- Looks for &quot;foo&quot;</span><span>
</span><span id="line-445"></span><span>         </span><span class="annot"><span class="annottext">String -&gt; ReadPrec String
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495282"><span class="hs-identifier hs-var">s</span></a></span><span>
</span><span id="line-446"></span><span>     </span><span class="annot"><span class="annottext">ReadPrec String -&gt; ReadPrec String -&gt; ReadPrec String
forall a. ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#%2B%2B%2B"><span class="hs-operator hs-var">+++</span></a></span><span>
</span><span id="line-447"></span><span>      </span><span class="annot"><span class="annottext">ReadPrec String
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>       </span><span class="hs-comment">-- Looks for ['f','o','o']</span><span>
</span><span id="line-448"></span><span>    </span><span class="hs-special">)</span><span>                           </span><span class="hs-comment">-- (more generous than H2010 spec)</span><span>
</span><span id="line-449"></span><span>
</span><span id="line-450"></span><span>  </span><span id="local-6989586621679495280"><span class="annot"><span class="annottext">readList :: ReadS String
</span><a href="#local-6989586621679495280"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS String
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-451"></span><span>
</span><span id="line-452"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-453"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495278"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Bool"><span class="hs-identifier hs-type">Bool</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-454"></span><span>  </span><span id="local-6989586621679495270"><span class="annot"><span class="annottext">readPrec :: ReadPrec Bool
</span><a href="#local-6989586621679495270"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-455"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec Bool -&gt; ReadPrec Bool
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-456"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-type">L.Ident</span></a></span><span> </span><span id="local-6989586621679495269"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495269"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-457"></span><span>         </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495269"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-458"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;True&quot;</span></span><span>  </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ReadPrec Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#True"><span class="hs-identifier hs-var">True</span></a></span><span>
</span><span id="line-459"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;False&quot;</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Bool -&gt; ReadPrec Bool
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Bool
</span><a href="../../ghc-prim/src/GHC.Types.html#False"><span class="hs-identifier hs-var">False</span></a></span><span>
</span><span id="line-460"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span>       </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec Bool
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-461"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-462"></span><span>
</span><span id="line-463"></span><span>  </span><span id="local-6989586621679495267"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Bool]
</span><a href="#local-6989586621679495267"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Bool]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-464"></span><span>  </span><span id="local-6989586621679495265"><span class="annot"><span class="annottext">readList :: ReadS [Bool]
</span><a href="#local-6989586621679495265"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Bool]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-465"></span><span>
</span><span id="line-466"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-467"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495263"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Ordering"><span class="hs-identifier hs-type">Ordering</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-468"></span><span>  </span><span id="local-6989586621679495254"><span class="annot"><span class="annottext">readPrec :: ReadPrec Ordering
</span><a href="#local-6989586621679495254"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-469"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec Ordering -&gt; ReadPrec Ordering
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-470"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-type">L.Ident</span></a></span><span> </span><span id="local-6989586621679495253"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495253"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-471"></span><span>         </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495253"><span class="hs-identifier hs-var">s</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-472"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;LT&quot;</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; ReadPrec Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#LT"><span class="hs-identifier hs-var">LT</span></a></span><span>
</span><span id="line-473"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;EQ&quot;</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; ReadPrec Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#EQ"><span class="hs-identifier hs-var">EQ</span></a></span><span>
</span><span id="line-474"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;GT&quot;</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Ordering -&gt; ReadPrec Ordering
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Ordering
</span><a href="../../ghc-prim/src/GHC.Types.html#GT"><span class="hs-identifier hs-var">GT</span></a></span><span>
</span><span id="line-475"></span><span>           </span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span>    </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">ReadPrec Ordering
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-476"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-477"></span><span>
</span><span id="line-478"></span><span>  </span><span id="local-6989586621679495251"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Ordering]
</span><a href="#local-6989586621679495251"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Ordering]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-479"></span><span>  </span><span id="local-6989586621679495249"><span class="annot"><span class="annottext">readList :: ReadS [Ordering]
</span><a href="#local-6989586621679495249"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Ordering]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-480"></span><span>
</span><span id="line-481"></span><span class="hs-comment">-- | @since 4.11.0.0</span><span>
</span><span id="line-482"></span><span id="local-6989586621679495234"><span id="local-6989586621679495242"><span id="local-6989586621679495245"><span id="local-6989586621679495247"><span id="local-6989586621679495893"><span class="hs-keyword">deriving</span><span> </span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495893"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Base.html#NonEmpty"><span class="hs-identifier hs-type">NonEmpty</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495893"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span></span></span><span>
</span><span id="line-483"></span><span>
</span><span id="line-484"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-485"></span><span class="hs-comment">-- Structure instances of Read: Maybe, List etc</span><span>
</span><span id="line-486"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-487"></span><span>
</span><span id="line-488"></span><span class="hs-comment">{-
For structured instances of Read we start using the precedences.  The
idea is then that 'parens (prec k p)' will fail immediately when trying
to parse it in a context with a higher precedence level than k. But if
there is one parenthesis parsed, then the required precedence level
drops to 0 again, and parsing inside p may succeed.

'appPrec' is just the precedence level of function application.  So,
if we are parsing function application, we'd better require the
precedence level to be at least 'appPrec'. Otherwise, we have to put
parentheses around it.

'step' is used to increase the precedence levels inside a
parser, and can be used to express left- or right- associativity. For
example, % is defined to be left associative, so we only increase
precedence on the right hand side.

Note how step is used in for example the Maybe parser to increase the
precedence beyond appPrec, so that basically only literals and
parenthesis-like objects such as (...) and [...] can be an argument to
'Just'.
-}</span><span>
</span><span id="line-510"></span><span>
</span><span id="line-511"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-512"></span><span id="local-6989586621679495892"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495231"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495892"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Maybe.html#Maybe"><span class="hs-identifier hs-type">Maybe</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495892"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-513"></span><span>  </span><span id="local-6989586621679495221"><span class="annot"><span class="annottext">readPrec :: ReadPrec (Maybe a)
</span><a href="#local-6989586621679495221"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-514"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-515"></span><span>    </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Nothing&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-516"></span><span>        </span><span class="annot"><span class="annottext">Maybe a -&gt; ReadPrec (Maybe a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">Maybe a
forall a. Maybe a
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span>
</span><span id="line-517"></span><span>     </span><span class="annot"><span class="annottext">ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall a. ReadPrec a -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#%2B%2B%2B"><span class="hs-operator hs-var">+++</span></a></span><span>
</span><span id="line-518"></span><span>     </span><span class="annot"><span class="annottext">Int -&gt; ReadPrec (Maybe a) -&gt; ReadPrec (Maybe a)
forall a. Int -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#prec"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Show.html#appPrec"><span class="hs-identifier hs-var">appPrec</span></a></span><span> </span><span class="hs-special">(</span><span>
</span><span id="line-519"></span><span>        </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Just&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-520"></span><span>           </span><span id="local-6989586621679495218"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495218"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-521"></span><span>           </span><span class="annot"><span class="annottext">Maybe a -&gt; ReadPrec (Maybe a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; Maybe a
forall a. a -&gt; Maybe a
</span><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-var">Just</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495218"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-522"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-523"></span><span>
</span><span id="line-524"></span><span>  </span><span id="local-6989586621679495215"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Maybe a]
</span><a href="#local-6989586621679495215"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Maybe a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-525"></span><span>  </span><span id="local-6989586621679495213"><span class="annot"><span class="annottext">readList :: ReadS [Maybe a]
</span><a href="#local-6989586621679495213"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Maybe a]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span><span>
</span><span id="line-526"></span><span>
</span><span id="line-527"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-528"></span><span id="local-6989586621679495944"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495211"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495944"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">[</span><span class="annot"><a href="#local-6989586621679495944"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">]</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-529"></span><span>  </span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="hs-pragma">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-pragma hs-type">Read</span></a></span><span> </span><span class="hs-pragma">[</span><span class="annot"><a href="GHC.Base.html#String"><span class="hs-pragma hs-type">String</span></a></span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-530"></span><span>  </span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="hs-pragma">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-pragma hs-type">Read</span></a></span><span> </span><span class="hs-pragma">[</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Char"><span class="hs-pragma hs-type">Char</span></a></span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-531"></span><span>  </span><span class="hs-pragma">{-# SPECIALISE</span><span> </span><span class="hs-pragma">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-pragma hs-type">Read</span></a></span><span> </span><span class="hs-pragma">[</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-pragma hs-type">Int</span></a></span><span class="hs-pragma">]</span><span> </span><span class="hs-pragma">#-}</span><span>
</span><span id="line-532"></span><span>  </span><span id="local-6989586621679495206"><span class="annot"><span class="annottext">readPrec :: ReadPrec [a]
</span><a href="#local-6989586621679495206"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrec"><span class="hs-identifier hs-var">readListPrec</span></a></span><span>
</span><span id="line-533"></span><span>  </span><span id="local-6989586621679495204"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [[a]]
</span><a href="#local-6989586621679495204"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [[a]]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-534"></span><span>  </span><span id="local-6989586621679495202"><span class="annot"><span class="annottext">readList :: ReadS [[a]]
</span><a href="#local-6989586621679495202"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [[a]]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span><span>
</span><span id="line-535"></span><span>
</span><span id="line-536"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-537"></span><span id="local-6989586621679495889"><span id="local-6989586621679495890"><span class="hs-keyword">instance</span><span>  </span><span id="local-6989586621679495200"><span class="hs-special">(</span><span class="annot"><a href="GHC.Ix.html#Ix"><span class="hs-identifier hs-type">Ix</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495890"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495890"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495889"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Arr.html#Array"><span class="hs-identifier hs-type">Array</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495890"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495889"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span>  </span><span class="hs-keyword">where</span><span>
</span><span id="line-538"></span><span>    </span><span id="local-6989586621679495188"><span class="annot"><span class="annottext">readPrec :: ReadPrec (Array a b)
</span><a href="#local-6989586621679495188"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (Array a b) -&gt; ReadPrec (Array a b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (Array a b) -&gt; ReadPrec (Array a b))
-&gt; ReadPrec (Array a b) -&gt; ReadPrec (Array a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadPrec (Array a b) -&gt; ReadPrec (Array a b)
forall a. Int -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#prec"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Show.html#appPrec"><span class="hs-identifier hs-var">appPrec</span></a></span><span> </span><span class="annot"><span class="annottext">(ReadPrec (Array a b) -&gt; ReadPrec (Array a b))
-&gt; ReadPrec (Array a b) -&gt; ReadPrec (Array a b)
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span>
</span><span id="line-539"></span><span>               </span><span class="hs-keyword">do</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-var">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;array&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-540"></span><span>                  </span><span id="local-6989586621679495187"><span class="annot"><span class="annottext">(a, a)
</span><a href="#local-6989586621679495187"><span class="hs-identifier hs-var">theBounds</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, a) -&gt; ReadPrec (a, a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, a)
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-541"></span><span>                  </span><span id="local-6989586621679495186"><span class="annot"><span class="annottext">[(a, b)]
</span><a href="#local-6989586621679495186"><span class="hs-identifier hs-var">vals</span></a></span></span><span>   </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b)] -&gt; ReadPrec [(a, b)]
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b)]
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-542"></span><span>                  </span><span class="annot"><span class="annottext">Array a b -&gt; ReadPrec (Array a b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">(a, a) -&gt; [(a, b)] -&gt; Array a b
forall i e. Ix i =&gt; (i, i) -&gt; [(i, e)] -&gt; Array i e
</span><a href="GHC.Arr.html#array"><span class="hs-identifier hs-var">array</span></a></span><span> </span><span class="annot"><span class="annottext">(a, a)
</span><a href="#local-6989586621679495187"><span class="hs-identifier hs-var">theBounds</span></a></span><span> </span><span class="annot"><span class="annottext">[(a, b)]
</span><a href="#local-6989586621679495186"><span class="hs-identifier hs-var">vals</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-543"></span><span>
</span><span id="line-544"></span><span>    </span><span id="local-6989586621679495183"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Array a b]
</span><a href="#local-6989586621679495183"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Array a b]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-545"></span><span>    </span><span id="local-6989586621679495181"><span class="annot"><span class="annottext">readList :: ReadS [Array a b]
</span><a href="#local-6989586621679495181"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Array a b]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span><span>
</span><span id="line-546"></span><span>
</span><span id="line-547"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-548"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495179"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-549"></span><span>  </span><span id="local-6989586621679495175"><span class="annot"><span class="annottext">readPrec :: ReadPrec Lexeme
</span><a href="#local-6989586621679495175"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-550"></span><span>  </span><span id="local-6989586621679495173"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Lexeme]
</span><a href="#local-6989586621679495173"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Lexeme]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-551"></span><span>  </span><span id="local-6989586621679495171"><span class="annot"><span class="annottext">readList :: ReadS [Lexeme]
</span><a href="#local-6989586621679495171"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Lexeme]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-552"></span><span>
</span><span id="line-553"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-554"></span><span class="hs-comment">-- Numeric instances of Read</span><span>
</span><span id="line-555"></span><span class="hs-comment">--------------------------------------------------------------</span><span>
</span><span id="line-556"></span><span>
</span><span id="line-557"></span><span id="local-6989586621679495884"><span class="annot"><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-type">readNumber</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Num.html#Num"><span class="hs-identifier hs-type">Num</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495884"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495884"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495884"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-558"></span><span class="hs-comment">-- Read a signed number</span><span>
</span><span id="line-559"></span><span id="readNumber"><span class="annot"><span class="annottext">readNumber :: forall a. Num a =&gt; (Lexeme -&gt; ReadPrec a) -&gt; ReadPrec a
</span><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-var hs-var">readNumber</span></a></span></span><span> </span><span id="local-6989586621679495164"><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec a
</span><a href="#local-6989586621679495164"><span class="hs-identifier hs-var">convert</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-560"></span><span>  </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-561"></span><span>  </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679495163"><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495163"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-562"></span><span>       </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495163"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-563"></span><span>         </span><span class="annot"><a href="Text.Read.Lex.html#Symbol"><span class="hs-identifier hs-type">L.Symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;-&quot;</span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679495162"><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495162"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec Lexeme
</span><a href="GHC.Read.html#lexP"><span class="hs-identifier hs-var">lexP</span></a></span><span>
</span><span id="line-564"></span><span>                            </span><span id="local-6989586621679495161"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495161"><span class="hs-identifier hs-var">n</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec a
</span><a href="#local-6989586621679495164"><span class="hs-identifier hs-var">convert</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495162"><span class="hs-identifier hs-var">y</span></a></span><span>
</span><span id="line-565"></span><span>                            </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a -&gt; a
forall a. Num a =&gt; a -&gt; a
</span><a href="GHC.Num.html#negate"><span class="hs-identifier hs-var">negate</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679495161"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-566"></span><span>
</span><span id="line-567"></span><span>         </span><span class="annot"><span class="annottext">Lexeme
</span><span class="hs-identifier">_</span></span><span>   </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec a
</span><a href="#local-6989586621679495164"><span class="hs-identifier hs-var">convert</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><a href="#local-6989586621679495163"><span class="hs-identifier hs-var">x</span></a></span><span>
</span><span id="line-568"></span><span>  </span><span class="hs-special">)</span><span>
</span><span id="line-569"></span><span>
</span><span id="line-570"></span><span>
</span><span id="line-571"></span><span id="local-6989586621679495881"><span class="annot"><a href="GHC.Read.html#convertInt"><span class="hs-identifier hs-type">convertInt</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="GHC.Num.html#Num"><span class="hs-identifier hs-type">Num</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495881"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495881"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-572"></span><span id="convertInt"><span class="annot"><span class="annottext">convertInt :: forall a. Num a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertInt"><span class="hs-identifier hs-var hs-var">convertInt</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Number"><span class="hs-identifier hs-type">L.Number</span></a></span><span> </span><span id="local-6989586621679495155"><span class="annot"><span class="annottext">Number
</span><a href="#local-6989586621679495155"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span>
</span><span id="line-573"></span><span> </span><span class="hs-glyph">|</span><span> </span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679495154"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495154"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Number -&gt; Maybe Integer
</span><a href="Text.Read.Lex.html#numberToInteger"><span class="hs-identifier hs-var">L.numberToInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Number
</span><a href="#local-6989586621679495155"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; a
forall a. Num a =&gt; Integer -&gt; a
</span><a href="GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495154"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-574"></span><span class="annot"><a href="GHC.Read.html#convertInt"><span class="hs-identifier hs-var">convertInt</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><span class="hs-identifier">_</span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-575"></span><span>
</span><span id="line-576"></span><span class="annot"><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-type">convertFrac</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-keyword">forall</span><span> </span><span id="local-6989586621679495878"><span class="annot"><a href="#local-6989586621679495878"><span class="hs-identifier hs-type">a</span></a></span></span><span> </span><span class="hs-operator">.</span><span> </span><span class="annot"><a href="GHC.Float.html#RealFloat"><span class="hs-identifier hs-type">RealFloat</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495878"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.Read.Lex.html#Lexeme"><span class="hs-identifier hs-type">L.Lexeme</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495878"><span class="hs-identifier hs-type">a</span></a></span><span>
</span><span id="line-577"></span><span id="convertFrac"><span class="annot"><span class="annottext">convertFrac :: forall a. RealFloat a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var hs-var">convertFrac</span></a></span></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-type">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;NaN&quot;</span></span><span class="hs-special">)</span><span>      </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Fractional a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Real.html#%2F"><span class="hs-operator hs-var">/</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-578"></span><span class="annot"><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var">convertFrac</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Ident"><span class="hs-identifier hs-type">L.Ident</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;Infinity&quot;</span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Fractional a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Real.html#%2F"><span class="hs-operator hs-var">/</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-579"></span><span class="annot"><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var">convertFrac</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="Text.Read.Lex.html#Number"><span class="hs-identifier hs-type">L.Number</span></a></span><span> </span><span id="local-6989586621679495127"><span class="annot"><span class="annottext">Number
</span><a href="#local-6989586621679495127"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">let</span><span> </span><span id="local-6989586621679495123"><span class="annot"><span class="annottext">resRange :: (Int, Int)
</span><a href="#local-6989586621679495123"><span class="hs-identifier hs-var hs-var">resRange</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">a -&gt; (Int, Int)
forall a. RealFloat a =&gt; a -&gt; (Int, Int)
</span><a href="GHC.Float.html#floatRange"><span class="hs-identifier hs-var">floatRange</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
forall a. HasCallStack =&gt; a
</span><a href="GHC.Err.html#undefined"><span class="hs-identifier hs-var">undefined</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="#local-6989586621679495878"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-580"></span><span>                           </span><span class="hs-keyword">in</span><span> </span><span class="hs-keyword">case</span><span> </span><span class="annot"><span class="annottext">(Int, Int) -&gt; Number -&gt; Maybe Rational
</span><a href="Text.Read.Lex.html#numberToRangedRational"><span class="hs-identifier hs-var">L.numberToRangedRational</span></a></span><span> </span><span class="annot"><span class="annottext">(Int, Int)
</span><a href="#local-6989586621679495123"><span class="hs-identifier hs-var">resRange</span></a></span><span> </span><span class="annot"><span class="annottext">Number
</span><a href="#local-6989586621679495127"><span class="hs-identifier hs-var">n</span></a></span><span> </span><span class="hs-keyword">of</span><span>
</span><span id="line-581"></span><span>                              </span><span class="annot"><span class="annottext">Maybe Rational
</span><a href="GHC.Maybe.html#Nothing"><span class="hs-identifier hs-var">Nothing</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><span class="hs-number">1</span></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; a
forall a. Fractional a =&gt; a -&gt; a -&gt; a
</span><a href="GHC.Real.html#%2F"><span class="hs-operator hs-var">/</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span>
</span><span id="line-582"></span><span>                              </span><span class="annot"><a href="GHC.Maybe.html#Just"><span class="hs-identifier hs-type">Just</span></a></span><span> </span><span id="local-6989586621679495119"><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621679495119"><span class="hs-identifier hs-var">rat</span></a></span></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><span class="annottext">a -&gt; ReadPrec a
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="annot"><span class="annottext">(a -&gt; ReadPrec a) -&gt; a -&gt; ReadPrec a
forall a b. (a -&gt; b) -&gt; a -&gt; b
</span><a href="GHC.Base.html#%24"><span class="hs-operator hs-var">$</span></a></span><span> </span><span class="annot"><span class="annottext">Rational -&gt; a
forall a. Fractional a =&gt; Rational -&gt; a
</span><a href="GHC.Real.html#fromRational"><span class="hs-identifier hs-var">fromRational</span></a></span><span> </span><span class="annot"><span class="annottext">Rational
</span><a href="#local-6989586621679495119"><span class="hs-identifier hs-var">rat</span></a></span><span>
</span><span id="line-583"></span><span class="annot"><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var">convertFrac</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme
</span><span class="hs-identifier">_</span></span><span>            </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#pfail"><span class="hs-identifier hs-var">pfail</span></a></span><span>
</span><span id="line-584"></span><span>
</span><span id="line-585"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-586"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495117"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-587"></span><span>  </span><span id="local-6989586621679495110"><span class="annot"><span class="annottext">readPrec :: ReadPrec Int
</span><a href="#local-6989586621679495110"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec Int) -&gt; ReadPrec Int
forall a. Num a =&gt; (Lexeme -&gt; ReadPrec a) -&gt; ReadPrec a
</span><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-var">readNumber</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec Int
forall a. Num a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertInt"><span class="hs-identifier hs-var">convertInt</span></a></span><span>
</span><span id="line-588"></span><span>  </span><span id="local-6989586621679495108"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Int]
</span><a href="#local-6989586621679495108"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Int]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-589"></span><span>  </span><span id="local-6989586621679495106"><span class="annot"><span class="annottext">readList :: ReadS [Int]
</span><a href="#local-6989586621679495106"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Int]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-590"></span><span>
</span><span id="line-591"></span><span class="hs-comment">-- | @since 4.5.0.0</span><span>
</span><span id="line-592"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495099"><span id="local-6989586621679495101"><span id="local-6989586621679495103"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Word"><span class="hs-identifier hs-type">Word</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-593"></span><span>    </span><span id="local-6989586621679495095"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Word
</span><a href="#local-6989586621679495095"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679495094"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495094"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679495093"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495093"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Word
forall a. Num a =&gt; Integer -&gt; a
</span><a href="GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495092"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495091"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495092"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495092"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679495091"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495091"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Integer
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495094"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495093"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-594"></span><span>
</span><span id="line-595"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-596"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495084"><span id="local-6989586621679495086"><span id="local-6989586621679495088"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word8"><span class="hs-identifier hs-type">Word8</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-597"></span><span>    </span><span id="local-6989586621679495078"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Word8
</span><a href="#local-6989586621679495078"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679495077"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495077"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679495076"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495076"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word8
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495075"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-glyph">::</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495074"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495075"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495075"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679495074"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495074"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Int
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495077"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495076"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-598"></span><span>
</span><span id="line-599"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-600"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495067"><span id="local-6989586621679495069"><span id="local-6989586621679495071"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word16"><span class="hs-identifier hs-type">Word16</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-601"></span><span>    </span><span id="local-6989586621679495062"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Word16
</span><a href="#local-6989586621679495062"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679495061"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495061"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679495060"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495060"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word16
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495059"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-glyph">::</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495058"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495059"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495059"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679495058"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495058"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Int
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495061"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495060"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-602"></span><span>
</span><span id="line-603"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-604"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495051"><span id="local-6989586621679495053"><span id="local-6989586621679495055"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word32"><span class="hs-identifier hs-type">Word32</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span class="hs-cpp">
#if WORD_SIZE_IN_BITS &lt; 33
</span><span>    </span><span class="hs-identifier">readsPrec</span><span> </span><span class="hs-identifier">p</span><span> </span><span class="hs-identifier">s</span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="hs-identifier">fromInteger</span><span> </span><span class="hs-identifier">x</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">r</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span class="hs-identifier">x</span><span class="hs-special">,</span><span> </span><span class="hs-identifier">r</span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="hs-identifier">readsPrec</span><span> </span><span class="hs-identifier">p</span><span> </span><span class="hs-identifier">s</span><span class="hs-special">]</span><span class="hs-cpp">
#else
</span><span>    </span><span id="local-6989586621679495046"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Word32
</span><a href="#local-6989586621679495046"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679495045"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495045"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679495044"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495044"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int -&gt; Word32
forall a b. (Integral a, Num b) =&gt; a -&gt; b
</span><a href="GHC.Real.html#fromIntegral"><span class="hs-identifier hs-var">fromIntegral</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495043"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-glyph">::</span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Int"><span class="hs-identifier hs-type">Int</span></a></span><span class="hs-special">)</span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495042"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495043"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495043"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679495042"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495042"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Int
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495045"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495044"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span class="hs-cpp">
#endif
</span><span>
</span><span id="line-611"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-612"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495035"><span id="local-6989586621679495037"><span id="local-6989586621679495039"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="GHC.Word.html#Word64"><span class="hs-identifier hs-type">Word64</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-613"></span><span>    </span><span id="local-6989586621679495031"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Word64
</span><a href="#local-6989586621679495031"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679495030"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495030"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span id="local-6989586621679495029"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495029"><span class="hs-identifier hs-var">s</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-special">[</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Word64
forall a. Num a =&gt; Integer -&gt; a
</span><a href="GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495028"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495027"><span class="hs-identifier hs-var">r</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">|</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679495028"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679495028"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679495027"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495027"><span class="hs-identifier hs-var">r</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Integer
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679495030"><span class="hs-identifier hs-var">p</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679495029"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">]</span><span>
</span><span id="line-614"></span><span>
</span><span id="line-615"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-616"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495025"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-bignum/src/GHC.Num.Integer.html#Integer"><span class="hs-identifier hs-type">Integer</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-617"></span><span>  </span><span id="local-6989586621679495018"><span class="annot"><span class="annottext">readPrec :: ReadPrec Integer
</span><a href="#local-6989586621679495018"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec Integer) -&gt; ReadPrec Integer
forall a. Num a =&gt; (Lexeme -&gt; ReadPrec a) -&gt; ReadPrec a
</span><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-var">readNumber</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec Integer
forall a. Num a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertInt"><span class="hs-identifier hs-var">convertInt</span></a></span><span>
</span><span id="line-618"></span><span>  </span><span id="local-6989586621679495016"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Integer]
</span><a href="#local-6989586621679495016"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Integer]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-619"></span><span>  </span><span id="local-6989586621679495014"><span class="annot"><span class="annottext">readList :: ReadS [Integer]
</span><a href="#local-6989586621679495014"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Integer]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-620"></span><span>
</span><span id="line-621"></span><span>
</span><span id="line-622"></span><span class="hs-comment">-- | @since 4.8.0.0</span><span>
</span><span id="line-623"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679495007"><span id="local-6989586621679495009"><span id="local-6989586621679495011"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-bignum/src/GHC.Num.Natural.html#Natural"><span class="hs-identifier hs-type">Natural</span></a></span></span></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-624"></span><span>  </span><span id="local-6989586621679495000"><span class="annot"><span class="annottext">readsPrec :: Int -&gt; ReadS Natural
</span><a href="#local-6989586621679495000"><span class="hs-identifier hs-var hs-var hs-var hs-var">readsPrec</span></a></span></span><span> </span><span id="local-6989586621679494999"><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679494999"><span class="hs-identifier hs-var">d</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">((Integer, String) -&gt; (Natural, String))
-&gt; [(Integer, String)] -&gt; [(Natural, String)]
forall a b. (a -&gt; b) -&gt; [a] -&gt; [b]
</span><a href="GHC.Base.html#map"><span class="hs-identifier hs-var">map</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679494998"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679494998"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">,</span><span> </span><span id="local-6989586621679494997"><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679494997"><span class="hs-identifier hs-var">s</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Natural
forall a. Num a =&gt; Integer -&gt; a
</span><a href="GHC.Num.html#fromInteger"><span class="hs-identifier hs-var">fromInteger</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679494998"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><span class="annottext">String
</span><a href="#local-6989586621679494997"><span class="hs-identifier hs-var">s</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span>
</span><span id="line-625"></span><span>                  </span><span class="annot"><span class="annottext">([(Integer, String)] -&gt; [(Natural, String)])
-&gt; ReadS Integer -&gt; ReadS Natural
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">((Integer, String) -&gt; Bool)
-&gt; [(Integer, String)] -&gt; [(Integer, String)]
forall a. (a -&gt; Bool) -&gt; [a] -&gt; [a]
</span><a href="GHC.List.html#filter"><span class="hs-identifier hs-var">filter</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">(</span><span class="annot"><span class="annottext">Integer -&gt; Integer -&gt; Bool
forall a. Ord a =&gt; a -&gt; a -&gt; Bool
</span><a href="../../ghc-prim/src/GHC.Classes.html#%3E%3D"><span class="hs-operator hs-var">&gt;=</span></a></span><span> </span><span class="annot"><span class="annottext">Integer
</span><span class="hs-number">0</span></span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">(Integer -&gt; Bool)
-&gt; ((Integer, String) -&gt; Integer) -&gt; (Integer, String) -&gt; Bool
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-glyph">\</span><span class="hs-special">(</span><span id="local-6989586621679494996"><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679494996"><span class="hs-identifier hs-var">x</span></a></span></span><span class="hs-special">,</span><span class="annot"><span class="annottext">String
</span><span class="hs-identifier">_</span></span><span class="hs-special">)</span><span class="hs-glyph">-&gt;</span><span class="annot"><span class="annottext">Integer
</span><a href="#local-6989586621679494996"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">)</span><span class="hs-special">)</span><span> </span><span class="annot"><span class="annottext">([(Integer, String)] -&gt; [(Integer, String)])
-&gt; ReadS Integer -&gt; ReadS Integer
forall b c a. (b -&gt; c) -&gt; (a -&gt; b) -&gt; a -&gt; c
</span><a href="GHC.Base.html#."><span class="hs-operator hs-var">.</span></a></span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadS Integer
forall a. Read a =&gt; Int -&gt; ReadS a
</span><a href="GHC.Read.html#readsPrec"><span class="hs-identifier hs-var">readsPrec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="#local-6989586621679494999"><span class="hs-identifier hs-var">d</span></a></span><span>
</span><span id="line-626"></span><span>
</span><span id="line-627"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-628"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494994"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Float"><span class="hs-identifier hs-type">Float</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-629"></span><span>  </span><span id="local-6989586621679494986"><span class="annot"><span class="annottext">readPrec :: ReadPrec Float
</span><a href="#local-6989586621679494986"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec Float) -&gt; ReadPrec Float
forall a. Num a =&gt; (Lexeme -&gt; ReadPrec a) -&gt; ReadPrec a
</span><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-var">readNumber</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec Float
forall a. RealFloat a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var">convertFrac</span></a></span><span>
</span><span id="line-630"></span><span>  </span><span id="local-6989586621679494984"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Float]
</span><a href="#local-6989586621679494984"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Float]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-631"></span><span>  </span><span id="local-6989586621679494982"><span class="annot"><span class="annottext">readList :: ReadS [Float]
</span><a href="#local-6989586621679494982"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Float]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-632"></span><span>
</span><span id="line-633"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-634"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494980"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="../../ghc-prim/src/GHC.Types.html#Double"><span class="hs-identifier hs-type">Double</span></a></span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-635"></span><span>  </span><span id="local-6989586621679494972"><span class="annot"><span class="annottext">readPrec :: ReadPrec Double
</span><a href="#local-6989586621679494972"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">(Lexeme -&gt; ReadPrec Double) -&gt; ReadPrec Double
forall a. Num a =&gt; (Lexeme -&gt; ReadPrec a) -&gt; ReadPrec a
</span><a href="GHC.Read.html#readNumber"><span class="hs-identifier hs-var">readNumber</span></a></span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec Double
forall a. RealFloat a =&gt; Lexeme -&gt; ReadPrec a
</span><a href="GHC.Read.html#convertFrac"><span class="hs-identifier hs-var">convertFrac</span></a></span><span>
</span><span id="line-636"></span><span>  </span><span id="local-6989586621679494970"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Double]
</span><a href="#local-6989586621679494970"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Double]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-637"></span><span>  </span><span id="local-6989586621679494968"><span class="annot"><span class="annottext">readList :: ReadS [Double]
</span><a href="#local-6989586621679494968"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Double]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-638"></span><span>
</span><span id="line-639"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-640"></span><span id="local-6989586621679495863"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494966"><span class="hs-special">(</span><span class="annot"><a href="GHC.Real.html#Integral"><span class="hs-identifier hs-type">Integral</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495863"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495863"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Real.html#Ratio"><span class="hs-identifier hs-type">Ratio</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495863"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-641"></span><span>  </span><span id="local-6989586621679494955"><span class="annot"><span class="annottext">readPrec :: ReadPrec (Ratio a)
</span><a href="#local-6989586621679494955"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-642"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec (Ratio a) -&gt; ReadPrec (Ratio a)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-643"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="annot"><span class="annottext">Int -&gt; ReadPrec (Ratio a) -&gt; ReadPrec (Ratio a)
forall a. Int -&gt; ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#prec"><span class="hs-identifier hs-var">prec</span></a></span><span> </span><span class="annot"><span class="annottext">Int
</span><a href="GHC.Real.html#ratioPrec"><span class="hs-identifier hs-var">ratioPrec</span></a></span><span>
</span><span id="line-644"></span><span>      </span><span class="hs-special">(</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679494953"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494953"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-645"></span><span>           </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Symbol"><span class="hs-identifier hs-var">L.Symbol</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;%&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-646"></span><span>           </span><span id="local-6989586621679494952"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494952"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="Text.ParserCombinators.ReadPrec.html#step"><span class="hs-identifier hs-var">step</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-647"></span><span>           </span><span class="annot"><span class="annottext">Ratio a -&gt; ReadPrec (Ratio a)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494953"><span class="hs-identifier hs-var">x</span></a></span><span> </span><span class="annot"><span class="annottext">a -&gt; a -&gt; Ratio a
forall a. Integral a =&gt; a -&gt; a -&gt; Ratio a
</span><a href="GHC.Real.html#%25"><span class="hs-operator hs-var">%</span></a></span><span> </span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494952"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-648"></span><span>      </span><span class="hs-special">)</span><span>
</span><span id="line-649"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-650"></span><span>
</span><span id="line-651"></span><span>  </span><span id="local-6989586621679494949"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [Ratio a]
</span><a href="#local-6989586621679494949"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [Ratio a]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-652"></span><span>  </span><span id="local-6989586621679494947"><span class="annot"><span class="annottext">readList :: ReadS [Ratio a]
</span><a href="#local-6989586621679494947"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [Ratio a]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span><span>
</span><span id="line-653"></span><span>
</span><span id="line-654"></span><span>
</span><span id="line-655"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-656"></span><span class="hs-comment">-- Tuple instances of Read, up to size 15</span><span>
</span><span id="line-657"></span><span class="hs-comment">------------------------------------------------------------------------</span><span>
</span><span id="line-658"></span><span>
</span><span id="line-659"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-660"></span><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494945"><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-661"></span><span>  </span><span id="local-6989586621679494940"><span class="annot"><span class="annottext">readPrec :: ReadPrec ()
</span><a href="#local-6989586621679494940"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span>
</span><span id="line-662"></span><span>    </span><span class="annot"><span class="annottext">ReadPrec () -&gt; ReadPrec ()
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span>
</span><span id="line-663"></span><span>    </span><span class="hs-special">(</span><span> </span><span class="annot"><span class="annottext">ReadPrec () -&gt; ReadPrec ()
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren"><span class="hs-identifier hs-var">paren</span></a></span><span>
</span><span id="line-664"></span><span>      </span><span class="hs-special">(</span><span> </span><span class="annot"><span class="annottext">() -&gt; ReadPrec ()
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-665"></span><span>      </span><span class="hs-special">)</span><span>
</span><span id="line-666"></span><span>    </span><span class="hs-special">)</span><span>
</span><span id="line-667"></span><span>
</span><span id="line-668"></span><span>  </span><span id="local-6989586621679494938"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [()]
</span><a href="#local-6989586621679494938"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [()]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-669"></span><span>  </span><span id="local-6989586621679494936"><span class="annot"><span class="annottext">readList :: ReadS [()]
</span><a href="#local-6989586621679494936"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [()]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span><span>
</span><span id="line-670"></span><span>
</span><span id="line-671"></span><span class="hs-comment">-- | @since 4.15</span><span>
</span><span id="line-672"></span><span id="local-6989586621679494923"><span id="local-6989586621679494929"><span id="local-6989586621679494932"><span id="local-6989586621679494934"><span id="local-6989586621679495861"><span class="hs-keyword">deriving</span><span> </span><span class="hs-keyword">instance</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495861"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="../../ghc-prim/src/GHC.Tuple.html#Solo"><span class="hs-identifier hs-type">Solo</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495861"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">)</span></span></span></span></span></span><span>
</span><span id="line-673"></span><span>
</span><span id="line-674"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-675"></span><span id="local-6989586621679495887"><span id="local-6989586621679495888"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494920"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495888"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495887"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495888"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495887"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-676"></span><span>  </span><span id="local-6989586621679494914"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b)
</span><a href="#local-6989586621679494914"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b) -&gt; ReadPrec (a, b)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-677"></span><span>  </span><span id="local-6989586621679494910"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b)]
</span><a href="#local-6989586621679494910"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-678"></span><span>  </span><span id="local-6989586621679494908"><span class="annot"><span class="annottext">readList :: ReadS [(a, b)]
</span><a href="#local-6989586621679494908"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span><span>
</span><span id="line-679"></span><span>
</span><span id="line-680"></span><span id="local-6989586621679494907"><span class="annot"><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-type">wrap_tup</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679494907"><span class="hs-identifier hs-type">a</span></a></span><span> </span><span class="hs-glyph">-&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679494907"><span class="hs-identifier hs-type">a</span></a></span></span><span>
</span><span id="line-681"></span><span id="wrap_tup"><span class="annot"><span class="annottext">wrap_tup :: forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var hs-var">wrap_tup</span></a></span></span><span> </span><span id="local-6989586621679494906"><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679494906"><span class="hs-identifier hs-var">p</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#parens"><span class="hs-identifier hs-var">parens</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">ReadPrec a -&gt; ReadPrec a
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#paren"><span class="hs-identifier hs-var">paren</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec a
</span><a href="#local-6989586621679494906"><span class="hs-identifier hs-var">p</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-682"></span><span>
</span><span id="line-683"></span><span class="annot"><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-type">read_comma</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-special">)</span><span>
</span><span id="line-684"></span><span id="read_comma"><span class="annot"><span class="annottext">read_comma :: ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var hs-var">read_comma</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">Lexeme -&gt; ReadPrec ()
</span><a href="GHC.Read.html#expectP"><span class="hs-identifier hs-var">expectP</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">String -&gt; Lexeme
</span><a href="Text.Read.Lex.html#Punc"><span class="hs-identifier hs-var">L.Punc</span></a></span><span> </span><span class="annot"><span class="annottext">String
</span><span class="hs-string">&quot;,&quot;</span></span><span class="hs-special">)</span><span>
</span><span id="line-685"></span><span>
</span><span id="line-686"></span><span id="local-6989586621679494903"><span id="local-6989586621679494904"><span class="annot"><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-type">read_tup2</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679494904"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679494903"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679494904"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679494903"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">)</span></span></span><span>
</span><span id="line-687"></span><span class="hs-comment">-- Reads &quot;a , b&quot;  no parens!</span><span>
</span><span id="line-688"></span><span id="read_tup2"><span class="annot"><span class="annottext">read_tup2 :: forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var hs-var">read_tup2</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span> </span><span id="local-6989586621679494894"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494894"><span class="hs-identifier hs-var">x</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec a
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-689"></span><span>               </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-690"></span><span>               </span><span id="local-6989586621679494893"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494893"><span class="hs-identifier hs-var">y</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec b
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-691"></span><span>               </span><span class="annot"><span class="annottext">(a, b) -&gt; ReadPrec (a, b)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494894"><span class="hs-identifier hs-var">x</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494893"><span class="hs-identifier hs-var">y</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-692"></span><span>
</span><span id="line-693"></span><span id="local-6989586621679495854"><span id="local-6989586621679495855"><span id="local-6989586621679495856"><span id="local-6989586621679495857"><span class="annot"><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-type">read_tup4</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495857"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495856"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495855"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495854"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495857"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495856"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495855"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495854"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span></span></span></span></span><span>
</span><span id="line-694"></span><span id="read_tup4"><span class="annot"><span class="annottext">read_tup4 :: forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var hs-var">read_tup4</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>  </span><span class="hs-special">(</span><span id="local-6989586621679494879"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494879"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494878"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494878"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-695"></span><span>                </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-696"></span><span>                </span><span class="hs-special">(</span><span id="local-6989586621679494877"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494877"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494876"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494876"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (c, d)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-697"></span><span>                </span><span class="annot"><span class="annottext">(a, b, c, d) -&gt; ReadPrec (a, b, c, d)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494879"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494878"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494877"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494876"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-698"></span><span>
</span><span id="line-699"></span><span>
</span><span id="line-700"></span><span id="local-6989586621679495842"><span id="local-6989586621679495843"><span id="local-6989586621679495844"><span id="local-6989586621679495845"><span id="local-6989586621679495846"><span id="local-6989586621679495847"><span id="local-6989586621679495848"><span id="local-6989586621679495849"><span class="annot"><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-type">read_tup8</span></a></span><span> </span><span class="hs-glyph">::</span><span> </span><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495849"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495848"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495847"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495846"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495845"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495844"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495843"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495842"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-701"></span><span>          </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="Text.ParserCombinators.ReadPrec.html#ReadPrec"><span class="hs-identifier hs-type">ReadPrec</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495849"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495848"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495847"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495846"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495845"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495844"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495843"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span class="annot"><a href="#local-6989586621679495842"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span></span></span></span></span></span></span></span></span><span>
</span><span id="line-702"></span><span id="read_tup8"><span class="annot"><span class="annottext">read_tup8 :: forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var hs-var">read_tup8</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="hs-keyword">do</span><span>  </span><span class="hs-special">(</span><span id="local-6989586621679494854"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494854"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494853"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494853"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494852"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494852"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494851"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494851"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span>
</span><span id="line-703"></span><span>                </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-704"></span><span>                </span><span class="hs-special">(</span><span id="local-6989586621679494850"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494850"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494849"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494849"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494848"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494848"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494847"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494847"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (e, f, g, h)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span>
</span><span id="line-705"></span><span>                </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h) -&gt; ReadPrec (a, b, c, d, e, f, g, h)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494854"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494853"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494852"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494851"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494850"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494849"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494848"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494847"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-706"></span><span>
</span><span id="line-707"></span><span>
</span><span id="line-708"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-709"></span><span id="local-6989586621679495831"><span id="local-6989586621679495832"><span id="local-6989586621679495833"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494845"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495833"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495832"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495831"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495833"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495832"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495831"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-710"></span><span>  </span><span id="local-6989586621679494834"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c)
</span><a href="#local-6989586621679494834"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c) -&gt; ReadPrec (a, b, c)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494833"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494833"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494832"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494832"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-711"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494831"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494831"><span class="hs-identifier hs-var">c</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec c
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-712"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c) -&gt; ReadPrec (a, b, c)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494833"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494832"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494831"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-713"></span><span>  </span><span id="local-6989586621679494829"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c)]
</span><a href="#local-6989586621679494829"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-714"></span><span>  </span><span id="local-6989586621679494827"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c)]
</span><a href="#local-6989586621679494827"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span><span>
</span><span id="line-715"></span><span>
</span><span id="line-716"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-717"></span><span id="local-6989586621679495827"><span id="local-6989586621679495828"><span id="local-6989586621679495829"><span id="local-6989586621679495830"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494825"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495830"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495829"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495828"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495827"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495830"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495829"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495828"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495827"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-718"></span><span>  </span><span id="local-6989586621679494817"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d)
</span><a href="#local-6989586621679494817"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d) -&gt; ReadPrec (a, b, c, d)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span>
</span><span id="line-719"></span><span>  </span><span id="local-6989586621679494815"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d)]
</span><a href="#local-6989586621679494815"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-720"></span><span>  </span><span id="local-6989586621679494813"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d)]
</span><a href="#local-6989586621679494813"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span><span>
</span><span id="line-721"></span><span>
</span><span id="line-722"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-723"></span><span id="local-6989586621679495822"><span id="local-6989586621679495823"><span id="local-6989586621679495824"><span id="local-6989586621679495825"><span id="local-6989586621679495826"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494811"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495826"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495825"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495824"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495823"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495822"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495826"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495825"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495824"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495823"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495822"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-724"></span><span>  </span><span id="local-6989586621679494798"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e)
</span><a href="#local-6989586621679494798"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e) -&gt; ReadPrec (a, b, c, d, e)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494797"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494797"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494796"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494796"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494795"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494795"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494794"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494794"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-725"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494793"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494793"><span class="hs-identifier hs-var">e</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec e
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-726"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e) -&gt; ReadPrec (a, b, c, d, e)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494797"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494796"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494795"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494794"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494793"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-727"></span><span>  </span><span id="local-6989586621679494791"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e)]
</span><a href="#local-6989586621679494791"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-728"></span><span>  </span><span id="local-6989586621679494789"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e)]
</span><a href="#local-6989586621679494789"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span><span>
</span><span id="line-729"></span><span>
</span><span id="line-730"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-731"></span><span id="local-6989586621679495816"><span id="local-6989586621679495817"><span id="local-6989586621679495818"><span id="local-6989586621679495819"><span id="local-6989586621679495820"><span id="local-6989586621679495821"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494787"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495821"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495820"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495819"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495818"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495817"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495816"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-732"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495821"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495820"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495819"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495818"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495817"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495816"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-733"></span><span>  </span><span id="local-6989586621679494773"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f)
</span><a href="#local-6989586621679494773"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f) -&gt; ReadPrec (a, b, c, d, e, f)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494772"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494772"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494771"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494771"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494770"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494770"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494769"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494769"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-734"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494768"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494768"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494767"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494767"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (e, f)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-735"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f) -&gt; ReadPrec (a, b, c, d, e, f)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494772"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494771"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494770"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494769"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494768"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494767"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-736"></span><span>  </span><span id="local-6989586621679494765"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f)]
</span><a href="#local-6989586621679494765"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-737"></span><span>  </span><span id="local-6989586621679494763"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f)]
</span><a href="#local-6989586621679494763"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span><span>
</span><span id="line-738"></span><span>
</span><span id="line-739"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-740"></span><span id="local-6989586621679495809"><span id="local-6989586621679495810"><span id="local-6989586621679495811"><span id="local-6989586621679495812"><span id="local-6989586621679495813"><span id="local-6989586621679495814"><span id="local-6989586621679495815"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494761"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495815"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495814"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495813"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495812"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495811"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495810"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495809"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-741"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495815"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495814"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495813"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495812"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495811"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495810"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495809"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-742"></span><span>  </span><span id="local-6989586621679494744"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g)
</span><a href="#local-6989586621679494744"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g) -&gt; ReadPrec (a, b, c, d, e, f, g)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494743"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494743"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494742"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494742"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494741"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494741"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494740"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494740"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-743"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494739"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494739"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494738"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494738"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (e, f)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-744"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494737"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494737"><span class="hs-identifier hs-var">g</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec g
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-745"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g) -&gt; ReadPrec (a, b, c, d, e, f, g)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494743"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494742"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494741"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494740"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494739"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494738"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494737"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-746"></span><span>  </span><span id="local-6989586621679494735"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g)]
</span><a href="#local-6989586621679494735"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-747"></span><span>  </span><span id="local-6989586621679494733"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g)]
</span><a href="#local-6989586621679494733"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span><span>
</span><span id="line-748"></span><span>
</span><span id="line-749"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-750"></span><span id="local-6989586621679495801"><span id="local-6989586621679495802"><span id="local-6989586621679495803"><span id="local-6989586621679495804"><span id="local-6989586621679495805"><span id="local-6989586621679495806"><span id="local-6989586621679495807"><span id="local-6989586621679495808"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494731"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495808"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495807"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495806"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495805"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495804"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495803"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495802"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495801"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-751"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495808"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495807"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495806"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495805"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495804"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495803"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495802"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495801"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-752"></span><span>  </span><span id="local-6989586621679494719"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="#local-6989586621679494719"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
-&gt; ReadPrec (a, b, c, d, e, f, g, h)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span>
</span><span id="line-753"></span><span>  </span><span id="local-6989586621679494717"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h)]
</span><a href="#local-6989586621679494717"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-754"></span><span>  </span><span id="local-6989586621679494715"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h)]
</span><a href="#local-6989586621679494715"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-755"></span><span>
</span><span id="line-756"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-757"></span><span id="local-6989586621679495792"><span id="local-6989586621679495793"><span id="local-6989586621679495794"><span id="local-6989586621679495795"><span id="local-6989586621679495796"><span id="local-6989586621679495797"><span id="local-6989586621679495798"><span id="local-6989586621679495799"><span id="local-6989586621679495800"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494713"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495800"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495799"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495798"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495797"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495796"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495795"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495794"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495793"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-758"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495792"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-759"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495800"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495799"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495798"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495797"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495796"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495795"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495794"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495793"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495792"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-760"></span><span>  </span><span id="local-6989586621679494696"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i)
</span><a href="#local-6989586621679494696"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494695"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494695"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494694"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494694"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494693"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494693"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494692"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494692"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494691"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494691"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494690"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494690"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494689"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494689"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494688"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494688"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-761"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494687"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494687"><span class="hs-identifier hs-var">i</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec i
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-762"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i) -&gt; ReadPrec (a, b, c, d, e, f, g, h, i)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494695"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494694"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494693"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494692"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494691"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494690"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494689"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494688"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494687"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-763"></span><span>  </span><span id="local-6989586621679494685"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i)]
</span><a href="#local-6989586621679494685"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-764"></span><span>  </span><span id="local-6989586621679494683"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i)]
</span><a href="#local-6989586621679494683"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-765"></span><span>
</span><span id="line-766"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-767"></span><span id="local-6989586621679495782"><span id="local-6989586621679495783"><span id="local-6989586621679495784"><span id="local-6989586621679495785"><span id="local-6989586621679495786"><span id="local-6989586621679495787"><span id="local-6989586621679495788"><span id="local-6989586621679495789"><span id="local-6989586621679495790"><span id="local-6989586621679495791"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494681"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495791"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495790"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495789"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495788"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495787"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495786"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495785"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495784"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-768"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495783"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495782"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-769"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495791"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495790"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495789"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495788"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495787"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495786"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495785"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495784"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495783"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495782"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-770"></span><span>  </span><span id="local-6989586621679494663"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j)
</span><a href="#local-6989586621679494663"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494662"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494662"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494661"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494661"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494660"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494660"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494659"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494659"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494658"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494658"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494657"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494657"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494656"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494656"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494655"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494655"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-771"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494654"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494654"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494653"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494653"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-772"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494662"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494661"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494660"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494659"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494658"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494657"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494656"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494655"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494654"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494653"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-773"></span><span>  </span><span id="local-6989586621679494651"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j)]
</span><a href="#local-6989586621679494651"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-774"></span><span>  </span><span id="local-6989586621679494649"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j)]
</span><a href="#local-6989586621679494649"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-775"></span><span>
</span><span id="line-776"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-777"></span><span id="local-6989586621679495771"><span id="local-6989586621679495772"><span id="local-6989586621679495773"><span id="local-6989586621679495774"><span id="local-6989586621679495775"><span id="local-6989586621679495776"><span id="local-6989586621679495777"><span id="local-6989586621679495778"><span id="local-6989586621679495779"><span id="local-6989586621679495780"><span id="local-6989586621679495781"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494647"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495781"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495780"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495779"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495778"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495777"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495776"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495775"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495774"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-778"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495773"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495772"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495771"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-779"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495781"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495780"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495779"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495778"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495777"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495776"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495775"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495774"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495773"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495772"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495771"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-780"></span><span>  </span><span id="local-6989586621679494626"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
</span><a href="#local-6989586621679494626"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494625"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494625"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494624"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494624"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494623"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494623"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494622"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494622"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494621"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494621"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494620"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494620"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494619"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494619"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494618"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494618"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-781"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494617"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494617"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494616"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494616"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-782"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494615"><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494615"><span class="hs-identifier hs-var">k</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec k
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-783"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j, k)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494625"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494624"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494623"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494622"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494621"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494620"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494619"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494618"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494617"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494616"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494615"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-784"></span><span>  </span><span id="local-6989586621679494613"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]
</span><a href="#local-6989586621679494613"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j, k)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-785"></span><span>  </span><span id="local-6989586621679494611"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k)]
</span><a href="#local-6989586621679494611"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j, k)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-786"></span><span>
</span><span id="line-787"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-788"></span><span id="local-6989586621679495759"><span id="local-6989586621679495760"><span id="local-6989586621679495761"><span id="local-6989586621679495762"><span id="local-6989586621679495763"><span id="local-6989586621679495764"><span id="local-6989586621679495765"><span id="local-6989586621679495766"><span id="local-6989586621679495767"><span id="local-6989586621679495768"><span id="local-6989586621679495769"><span id="local-6989586621679495770"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494609"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495770"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495769"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495768"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495767"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495766"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495765"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495764"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495763"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-789"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495762"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495761"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495760"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495759"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-790"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495770"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495769"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495768"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495767"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495766"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495765"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495764"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495763"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495762"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495761"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495760"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495759"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-791"></span><span>  </span><span id="local-6989586621679494589"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
</span><a href="#local-6989586621679494589"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494588"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494588"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494587"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494587"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494586"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494586"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494585"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494585"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494584"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494584"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494583"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494583"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494582"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494582"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494581"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494581"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-792"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494580"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494580"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494579"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494579"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494578"><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494578"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494577"><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494577"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span>
</span><span id="line-793"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j, k, l)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494588"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494587"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494586"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494585"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494584"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494583"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494582"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494581"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494580"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494579"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494578"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494577"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-794"></span><span>  </span><span id="local-6989586621679494575"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]
</span><a href="#local-6989586621679494575"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-795"></span><span>  </span><span id="local-6989586621679494573"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)]
</span><a href="#local-6989586621679494573"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j, k, l)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-796"></span><span>
</span><span id="line-797"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-798"></span><span id="local-6989586621679495746"><span id="local-6989586621679495747"><span id="local-6989586621679495748"><span id="local-6989586621679495749"><span id="local-6989586621679495750"><span id="local-6989586621679495751"><span id="local-6989586621679495752"><span id="local-6989586621679495753"><span id="local-6989586621679495754"><span id="local-6989586621679495755"><span id="local-6989586621679495756"><span id="local-6989586621679495757"><span id="local-6989586621679495758"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494571"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495758"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495757"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495756"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495755"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495754"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495753"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495752"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495751"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-799"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495750"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495749"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495748"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495747"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495746"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-800"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495758"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495757"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495756"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495755"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495754"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495753"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495752"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495751"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495750"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495749"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495748"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495747"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495746"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-801"></span><span>  </span><span id="local-6989586621679494548"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
</span><a href="#local-6989586621679494548"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494547"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494547"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494546"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494546"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494545"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494545"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494544"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494544"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494543"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494543"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494542"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494542"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494541"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494541"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494540"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494540"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-802"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494539"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494539"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494538"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494538"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494537"><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494537"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494536"><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494536"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-803"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494535"><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494535"><span class="hs-identifier hs-var">m</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec m
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-804"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j, k, l, m)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494547"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494546"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494545"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494544"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494543"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494542"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494541"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494540"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494539"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494538"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494537"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494536"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494535"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-805"></span><span>  </span><span id="local-6989586621679494533"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
</span><a href="#local-6989586621679494533"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-806"></span><span>  </span><span id="local-6989586621679494531"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
</span><a href="#local-6989586621679494531"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-807"></span><span>
</span><span id="line-808"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-809"></span><span id="local-6989586621679495732"><span id="local-6989586621679495733"><span id="local-6989586621679495734"><span id="local-6989586621679495735"><span id="local-6989586621679495736"><span id="local-6989586621679495737"><span id="local-6989586621679495738"><span id="local-6989586621679495739"><span id="local-6989586621679495740"><span id="local-6989586621679495741"><span id="local-6989586621679495742"><span id="local-6989586621679495743"><span id="local-6989586621679495744"><span id="local-6989586621679495745"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494529"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495745"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495744"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495743"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495742"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495741"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495740"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495739"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495738"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-810"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495737"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495736"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495735"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495734"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495733"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495732"><span class="hs-identifier hs-type">n</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-811"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495745"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495744"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495743"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495742"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495741"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495740"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495739"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495738"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495737"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495736"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495735"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495734"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495733"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495732"><span class="hs-identifier hs-type">n</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-812"></span><span>  </span><span id="local-6989586621679494505"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
</span><a href="#local-6989586621679494505"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494504"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494504"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494503"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494503"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494502"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494502"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494501"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494501"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494500"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494500"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494499"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494499"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494498"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494498"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494497"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494497"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-813"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494496"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494496"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494495"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494495"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494494"><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494494"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494493"><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494493"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-814"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494492"><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494492"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494491"><span class="annot"><span class="annottext">n
</span><a href="#local-6989586621679494491"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (m, n)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span>
</span><span id="line-815"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494504"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494503"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494502"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494501"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494500"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494499"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494498"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494497"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494496"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494495"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494494"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494493"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494492"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">n
</span><a href="#local-6989586621679494491"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-816"></span><span>  </span><span id="local-6989586621679494489"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
</span><a href="#local-6989586621679494489"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-817"></span><span>  </span><span id="local-6989586621679494487"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
</span><a href="#local-6989586621679494487"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-818"></span><span>
</span><span id="line-819"></span><span class="hs-comment">-- | @since 2.01</span><span>
</span><span id="line-820"></span><span id="local-6989586621679495717"><span id="local-6989586621679495718"><span id="local-6989586621679495719"><span id="local-6989586621679495720"><span id="local-6989586621679495721"><span id="local-6989586621679495722"><span id="local-6989586621679495723"><span id="local-6989586621679495724"><span id="local-6989586621679495725"><span id="local-6989586621679495726"><span id="local-6989586621679495727"><span id="local-6989586621679495728"><span id="local-6989586621679495729"><span id="local-6989586621679495730"><span id="local-6989586621679495731"><span class="hs-keyword">instance</span><span> </span><span id="local-6989586621679494485"><span class="hs-special">(</span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495731"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495730"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495729"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495728"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495727"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495726"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495725"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495724"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span>
</span><span id="line-821"></span><span>          </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495723"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495722"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495721"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495720"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495719"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495718"><span class="hs-identifier hs-type">n</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="annot"><a href="#local-6989586621679495717"><span class="hs-identifier hs-type">o</span></a></span><span class="hs-special">)</span><span>
</span><span id="line-822"></span><span>        </span><span class="hs-glyph">=&gt;</span><span> </span><span class="annot"><a href="GHC.Read.html#Read"><span class="hs-identifier hs-type">Read</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><a href="#local-6989586621679495731"><span class="hs-identifier hs-type">a</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495730"><span class="hs-identifier hs-type">b</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495729"><span class="hs-identifier hs-type">c</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495728"><span class="hs-identifier hs-type">d</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495727"><span class="hs-identifier hs-type">e</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495726"><span class="hs-identifier hs-type">f</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495725"><span class="hs-identifier hs-type">g</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495724"><span class="hs-identifier hs-type">h</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495723"><span class="hs-identifier hs-type">i</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495722"><span class="hs-identifier hs-type">j</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495721"><span class="hs-identifier hs-type">k</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495720"><span class="hs-identifier hs-type">l</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495719"><span class="hs-identifier hs-type">m</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495718"><span class="hs-identifier hs-type">n</span></a></span><span class="hs-special">,</span><span> </span><span class="annot"><a href="#local-6989586621679495717"><span class="hs-identifier hs-type">o</span></a></span><span class="hs-special">)</span></span><span> </span><span class="hs-keyword">where</span><span>
</span><span id="line-823"></span><span>  </span><span id="local-6989586621679494458"><span class="annot"><span class="annottext">readPrec :: ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
</span><a href="#local-6989586621679494458"><span class="hs-identifier hs-var hs-var hs-var hs-var">readPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
forall a. ReadPrec a -&gt; ReadPrec a
</span><a href="GHC.Read.html#wrap_tup"><span class="hs-identifier hs-var">wrap_tup</span></a></span><span> </span><span class="hs-special">(</span><span class="hs-keyword">do</span><span> </span><span class="hs-special">{</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494457"><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494457"><span class="hs-identifier hs-var">a</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494456"><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494456"><span class="hs-identifier hs-var">b</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494455"><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494455"><span class="hs-identifier hs-var">c</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494454"><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494454"><span class="hs-identifier hs-var">d</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494453"><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494453"><span class="hs-identifier hs-var">e</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494452"><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494452"><span class="hs-identifier hs-var">f</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494451"><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494451"><span class="hs-identifier hs-var">g</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494450"><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494450"><span class="hs-identifier hs-var">h</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (a, b, c, d, e, f, g, h)
forall a b c d e f g h.
(Read a, Read b, Read c, Read d, Read e, Read f, Read g, Read h) =&gt;
ReadPrec (a, b, c, d, e, f, g, h)
</span><a href="GHC.Read.html#read_tup8"><span class="hs-identifier hs-var">read_tup8</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-824"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494449"><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494449"><span class="hs-identifier hs-var">i</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494448"><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494448"><span class="hs-identifier hs-var">j</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494447"><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494447"><span class="hs-identifier hs-var">k</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494446"><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494446"><span class="hs-identifier hs-var">l</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (i, j, k, l)
forall a b c d.
(Read a, Read b, Read c, Read d) =&gt;
ReadPrec (a, b, c, d)
</span><a href="GHC.Read.html#read_tup4"><span class="hs-identifier hs-var">read_tup4</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-825"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="hs-special">(</span><span id="local-6989586621679494445"><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494445"><span class="hs-identifier hs-var">m</span></a></span></span><span class="hs-special">,</span><span id="local-6989586621679494444"><span class="annot"><span class="annottext">n
</span><a href="#local-6989586621679494444"><span class="hs-identifier hs-var">n</span></a></span></span><span class="hs-special">)</span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec (m, n)
forall a b. (Read a, Read b) =&gt; ReadPrec (a, b)
</span><a href="GHC.Read.html#read_tup2"><span class="hs-identifier hs-var">read_tup2</span></a></span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">ReadPrec ()
</span><a href="GHC.Read.html#read_comma"><span class="hs-identifier hs-var">read_comma</span></a></span><span>
</span><span id="line-826"></span><span>                          </span><span class="hs-special">;</span><span> </span><span id="local-6989586621679494443"><span class="annot"><span class="annottext">o
</span><a href="#local-6989586621679494443"><span class="hs-identifier hs-var">o</span></a></span></span><span> </span><span class="hs-glyph">&lt;-</span><span> </span><span class="annot"><span class="annottext">ReadPrec o
forall a. Read a =&gt; ReadPrec a
</span><a href="GHC.Read.html#readPrec"><span class="hs-identifier hs-var">readPrec</span></a></span><span>
</span><span id="line-827"></span><span>                          </span><span class="hs-special">;</span><span> </span><span class="annot"><span class="annottext">(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
-&gt; ReadPrec (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
forall (m :: * -&gt; *) a. Monad m =&gt; a -&gt; m a
</span><a href="GHC.Base.html#return"><span class="hs-identifier hs-var">return</span></a></span><span> </span><span class="hs-special">(</span><span class="annot"><span class="annottext">a
</span><a href="#local-6989586621679494457"><span class="hs-identifier hs-var">a</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">b
</span><a href="#local-6989586621679494456"><span class="hs-identifier hs-var">b</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">c
</span><a href="#local-6989586621679494455"><span class="hs-identifier hs-var">c</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">d
</span><a href="#local-6989586621679494454"><span class="hs-identifier hs-var">d</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">e
</span><a href="#local-6989586621679494453"><span class="hs-identifier hs-var">e</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">f
</span><a href="#local-6989586621679494452"><span class="hs-identifier hs-var">f</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">g
</span><a href="#local-6989586621679494451"><span class="hs-identifier hs-var">g</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">h
</span><a href="#local-6989586621679494450"><span class="hs-identifier hs-var">h</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">i
</span><a href="#local-6989586621679494449"><span class="hs-identifier hs-var">i</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">j
</span><a href="#local-6989586621679494448"><span class="hs-identifier hs-var">j</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">k
</span><a href="#local-6989586621679494447"><span class="hs-identifier hs-var">k</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">l
</span><a href="#local-6989586621679494446"><span class="hs-identifier hs-var">l</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">m
</span><a href="#local-6989586621679494445"><span class="hs-identifier hs-var">m</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">n
</span><a href="#local-6989586621679494444"><span class="hs-identifier hs-var">n</span></a></span><span class="hs-special">,</span><span class="annot"><span class="annottext">o
</span><a href="#local-6989586621679494443"><span class="hs-identifier hs-var">o</span></a></span><span class="hs-special">)</span><span> </span><span class="hs-special">}</span><span class="hs-special">)</span><span>
</span><span id="line-828"></span><span>  </span><span id="local-6989586621679494441"><span class="annot"><span class="annottext">readListPrec :: ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
</span><a href="#local-6989586621679494441"><span class="hs-identifier hs-var hs-var hs-var hs-var">readListPrec</span></a></span></span><span> </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadPrec [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
forall a. Read a =&gt; ReadPrec [a]
</span><a href="GHC.Read.html#readListPrecDefault"><span class="hs-identifier hs-var">readListPrecDefault</span></a></span><span>
</span><span id="line-829"></span><span>  </span><span id="local-6989586621679494439"><span class="annot"><span class="annottext">readList :: ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
</span><a href="#local-6989586621679494439"><span class="hs-identifier hs-var hs-var hs-var hs-var">readList</span></a></span></span><span>     </span><span class="hs-glyph">=</span><span> </span><span class="annot"><span class="annottext">ReadS [(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)]
forall a. Read a =&gt; ReadS [a]
</span><a href="GHC.Read.html#readListDefault"><span class="hs-identifier hs-var">readListDefault</span></a></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span></span><span>
</span><span id="line-830"></span></pre></body></html>